From 69f4669ccca584a64a69e2d9c53a05d847e8b403 Mon Sep 17 00:00:00 2001
From: Niels Werensteijn <nwerensteijn@users.noreply.github.com>
Date: Mon, 3 Mar 2014 17:29:50 +0100
Subject: [PATCH 01/41] Three fixes to get this lib compiled on linux g++ 4.7.3

Added <stdexcept> include to amqpcpp.h
Removed virtual destructors for exception.h and protocolexception.h. They were causing compile issues because of (no) noexcept specification. They were empty implementations anyway, and the ~std::exception was already virtual, so they were not needed anyway.
---
 amqpcpp.h               | 1 +
 src/exception.h         | 6 ------
 src/protocolexception.h | 5 -----
 3 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/amqpcpp.h b/amqpcpp.h
index 0708362..3ae5c67 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -16,6 +16,7 @@
 #include <limits>
 #include <cstddef>
 #include <cstring>
+#include <stdexcept>
 
 // base C include files
 #include <stdint.h>
diff --git a/src/exception.h b/src/exception.h
index 17d81f7..e4bb35a 100644
--- a/src/exception.h
+++ b/src/exception.h
@@ -22,12 +22,6 @@ protected:
      *  @param  what
      */
     explicit Exception(const std::string &what) : runtime_error(what) {}
-
-public:
-    /**
-     *  Destructor
-     */
-    virtual ~Exception() {}
 };
     
 /**
diff --git a/src/protocolexception.h b/src/protocolexception.h
index 9973f0b..7f829bc 100644
--- a/src/protocolexception.h
+++ b/src/protocolexception.h
@@ -23,11 +23,6 @@ public:
      *  @param  what
      */
     explicit ProtocolException(const std::string &what) : Exception(what) {}
-    
-    /**
-     *  Destructor
-     */
-    virtual ~ProtocolException() {}
 };
 
 /**

From 72d0b18fe6be9120cd40e6a79104e14701a7da37 Mon Sep 17 00:00:00 2001
From: root <root@dev01.weblink.se>
Date: Thu, 20 Mar 2014 11:17:47 -0400
Subject: [PATCH 02/41] fix namespace in readme

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6777e3f..79da95c 100644
--- a/README.md
+++ b/README.md
@@ -63,7 +63,7 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
      *  to use.
      *  @param  connection      The connection that can now be used
      */
-    virtual void onConnected(Connection *connection)
+    virtual void onConnected(AMQP::Connection *connection)
     {
         // @todo
         //  add your own implementation, for example by creating a channel 
@@ -77,7 +77,7 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
      *  @param  connection      The connection on which the error occured
      *  @param  message         A human readable error message
      */
-    virtual void onError(Connection *connection, const std::string &message)
+    virtual void onError(AMQP::Connection *connection, const std::string &message)
     {
         // @todo
         //  add your own implementation, for example by reporting the error

From 47f5ec2710873031cbc2b95c6cf5983df295b5ad Mon Sep 17 00:00:00 2001
From: Luca Marturana <luca.marturana@a-tono.com>
Date: Wed, 2 Apr 2014 11:53:46 +0200
Subject: [PATCH 03/41] On connection::parse char* can be const

---
 include/connection.h     | 2 +-
 include/connectionimpl.h | 2 +-
 src/connectionimpl.cpp   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/connection.h b/include/connection.h
index 64298a8..64e0ea1 100644
--- a/include/connection.h
+++ b/include/connection.h
@@ -74,7 +74,7 @@ public:
      *  @param  size        size of the buffer to decode
      *  @return             number of bytes that were processed
      */
-    size_t parse(char *buffer, size_t size)
+    size_t parse(const char *buffer, size_t size)
     {
         return _implementation.parse(buffer, size);
     }
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index 1755281..780c0ff 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -234,7 +234,7 @@ public:
      *  @param  size        size of the buffer to decode
      *  @return             number of bytes that were processed
      */
-    size_t parse(char *buffer, size_t size);
+    size_t parse(const char *buffer, size_t size);
 
     /**
      *  Close the connection
diff --git a/src/connectionimpl.cpp b/src/connectionimpl.cpp
index 1a37f4a..8f40fde 100644
--- a/src/connectionimpl.cpp
+++ b/src/connectionimpl.cpp
@@ -104,7 +104,7 @@ void ConnectionImpl::remove(ChannelImpl *channel)
  *  @param  size        size of the buffer to decode
  *  @return             number of bytes that were processed
  */
-size_t ConnectionImpl::parse(char *buffer, size_t size)
+size_t ConnectionImpl::parse(const char *buffer, size_t size)
 {
     // do not parse if already in an error state
     if (_state == state_closed) return 0;

From 41c1402d15efafd0addc9aa2d4f80058e5bf535d Mon Sep 17 00:00:00 2001
From: Luca Marturana <lucamarturana@gmail.com>
Date: Wed, 2 Apr 2014 12:59:24 +0200
Subject: [PATCH 04/41] Const modifier to table get and some array operations

---
 include/array.h | 27 +++++++++++++++++++++++----
 include/table.h |  2 +-
 src/array.cpp   | 25 ++++++++++++++++++++-----
 src/table.cpp   |  2 +-
 4 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/include/array.h b/include/array.h
index befd1d6..98f78c5 100644
--- a/include/array.h
+++ b/include/array.h
@@ -1,6 +1,6 @@
 /**
  *  AMQP field array
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -20,7 +20,7 @@ private:
      *  @typedef
      */
     typedef std::vector<std::shared_ptr<Field>> FieldArray;
-    
+
     /**
      *  The actual fields
      *  @var FieldArray
@@ -30,7 +30,7 @@ private:
 public:
     /**
      *  Constructor to construct an array from a received frame
-     * 
+     *
      *  @param  frame   received frame
      */
     Array(ReceivedFrame &frame);
@@ -99,6 +99,25 @@ public:
      */
     const Field &get(uint8_t index);
 
+    /**
+     *  Get number of elements on this array
+     *
+     *  @return array size
+     */
+    uint32_t count() const;
+
+    /**
+     * Remove last element from array
+     */
+    void pop_back();
+
+    /**
+     * Add field to end of array
+     *
+     * @param value
+     */
+    void push_back(const Field &value);
+
     /**
      *  Get a field
      *
@@ -111,7 +130,7 @@ public:
     }
 
     /**
-     *  Write encoded payload to the given buffer. 
+     *  Write encoded payload to the given buffer.
      *  @param  buffer
      */
     virtual void fill(OutBuffer& buffer) const override;
diff --git a/include/table.h b/include/table.h
index c26fb6d..5343769 100644
--- a/include/table.h
+++ b/include/table.h
@@ -109,7 +109,7 @@ public:
      *  @param  name    field name
      *  @return         the field value
      */
-    const Field &get(const std::string &name);
+    const Field &get(const std::string &name) const;
 
     /**
      *  Get a field
diff --git a/src/array.cpp b/src/array.cpp
index 3b5831b..706572d 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -1,8 +1,8 @@
 /**
  *  Array.cpp
- * 
+ *
  *  Implementation of an array
- * 
+ *
  */
 #include "includes.h"
 
@@ -23,7 +23,7 @@ Array::Array(ReceivedFrame &frame)
     {
         // one byte less for the field type
         charsToRead -= 1;
-        
+
         // read the field type and construct the field
         Field *field = Field::decode(frame);
         if (!field) continue;
@@ -62,7 +62,7 @@ const Field &Array::get(uint8_t index)
 {
     // used if index does not exist
     static ShortString empty;
-    
+
     // check whether we have that many elements
     if (index >= _fields.size()) return empty;
 
@@ -70,6 +70,21 @@ const Field &Array::get(uint8_t index)
     return *_fields[index];
 }
 
+uint32_t Array::count() const
+{
+  return _fields.size();
+}
+
+void Array::pop_back()
+{
+    _fields.pop_back();
+}
+
+void Array::push_back(const Field& value)
+{
+    _fields.push_back(std::shared_ptr<Field>(value.clone()));
+}
+
 /**
  *  Get the size this field will take when
  *  encoded in the AMQP wire-frame format
@@ -92,7 +107,7 @@ size_t Array::size() const
 }
 
 /**
- *  Write encoded payload to the given buffer. 
+ *  Write encoded payload to the given buffer.
  */
 void Array::fill(OutBuffer& buffer) const
 {
diff --git a/src/table.cpp b/src/table.cpp
index ba41983..4be9b11 100644
--- a/src/table.cpp
+++ b/src/table.cpp
@@ -97,7 +97,7 @@ Table &Table::operator=(Table &&table)
  *  @param  name    field name
  *  @return         the field value
  */
-const Field &Table::get(const std::string &name)
+const Field &Table::get(const std::string &name) const
 {
     // we need an empty string
     static ShortString empty;

From 17be969d49f2c1d8327b3dc3898f46820f22e2a1 Mon Sep 17 00:00:00 2001
From: Luca Marturana <lucamarturana@gmail.com>
Date: Wed, 2 Apr 2014 15:40:35 +0200
Subject: [PATCH 05/41] Add pragma once

---
 include/array.h             | 1 +
 include/booleanset.h        | 1 +
 include/channel.h           | 1 +
 include/channelhandler.h    | 1 +
 include/channelimpl.h       | 1 +
 include/classes.h           | 1 +
 include/connection.h        | 1 +
 include/connectionhandler.h | 1 +
 include/connectionimpl.h    | 1 +
 include/decimalfield.h      | 1 +
 include/entityimpl.h        | 1 +
 include/envelope.h          | 1 +
 include/exchangetype.h      | 1 +
 include/field.h             | 1 +
 include/fieldproxy.h        | 1 +
 include/flags.h             | 1 +
 include/login.h             | 1 +
 include/message.h           | 1 +
 include/metadata.h          | 1 +
 include/numericfield.h      | 1 +
 include/outbuffer.h         | 1 +
 include/receivedframe.h     | 1 +
 include/stringfield.h       | 1 +
 include/table.h             | 1 +
 include/watchable.h         | 1 +
 25 files changed, 25 insertions(+)

diff --git a/include/array.h b/include/array.h
index 98f78c5..7e59406 100644
--- a/include/array.h
+++ b/include/array.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  AMQP field array
  *
diff --git a/include/booleanset.h b/include/booleanset.h
index 6383ab2..577fe47 100644
--- a/include/booleanset.h
+++ b/include/booleanset.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  BooleanSet.h
  *
diff --git a/include/channel.h b/include/channel.h
index 0b36dba..d9dae3e 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Class describing a (mid-level) AMQP channel implementation
  * 
diff --git a/include/channelhandler.h b/include/channelhandler.h
index ad0c001..c0d3438 100644
--- a/include/channelhandler.h
+++ b/include/channelhandler.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  ChannelHandler.h
  *
diff --git a/include/channelimpl.h b/include/channelimpl.h
index ad02d27..77e4f16 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  ChannelImpl.h
  *
diff --git a/include/classes.h b/include/classes.h
index af49200..b4a5500 100644
--- a/include/classes.h
+++ b/include/classes.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Classes.h
  *
diff --git a/include/connection.h b/include/connection.h
index 64e0ea1..a67e6ad 100644
--- a/include/connection.h
+++ b/include/connection.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Class describing a mid-level Amqp connection
  * 
diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 5233948..7a90b50 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  ConnectionHandler.h
  *
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index 780c0ff..77adada 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Connection implementation
  *
diff --git a/include/decimalfield.h b/include/decimalfield.h
index 5df085b..c9d3cfc 100644
--- a/include/decimalfield.h
+++ b/include/decimalfield.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Decimal field type for AMQP
  * 
diff --git a/include/entityimpl.h b/include/entityimpl.h
index 51ac4ac..be5207d 100644
--- a/include/entityimpl.h
+++ b/include/entityimpl.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  EntityImpl.h
  *
diff --git a/include/envelope.h b/include/envelope.h
index f66331f..fbe646e 100644
--- a/include/envelope.h
+++ b/include/envelope.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Envelope.h
  *
diff --git a/include/exchangetype.h b/include/exchangetype.h
index a5e7929..ea6ade8 100644
--- a/include/exchangetype.h
+++ b/include/exchangetype.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  ExchangeType.h
  *
diff --git a/include/field.h b/include/field.h
index 41fbdca..079c741 100644
--- a/include/field.h
+++ b/include/field.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Available field types for AMQP
  * 
diff --git a/include/fieldproxy.h b/include/fieldproxy.h
index 947d6cc..ad8c445 100644
--- a/include/fieldproxy.h
+++ b/include/fieldproxy.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Field proxy. Returned by the table. Can be casted to the
  *  relevant native type (std::string or numeric)
diff --git a/include/flags.h b/include/flags.h
index 0a9c2ee..5f46b52 100644
--- a/include/flags.h
+++ b/include/flags.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  AmqpFlags.h
  *
diff --git a/include/login.h b/include/login.h
index 7605696..51f79de 100644
--- a/include/login.h
+++ b/include/login.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  The login information to access a server
  *
diff --git a/include/message.h b/include/message.h
index a036420..c92cc5e 100644
--- a/include/message.h
+++ b/include/message.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Message.h
  *
diff --git a/include/metadata.h b/include/metadata.h
index 7c1714a..42bf051 100644
--- a/include/metadata.h
+++ b/include/metadata.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  MetaData.h
  *
diff --git a/include/numericfield.h b/include/numericfield.h
index bcddf58..82edf99 100644
--- a/include/numericfield.h
+++ b/include/numericfield.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Numeric field types for AMQP
  * 
diff --git a/include/outbuffer.h b/include/outbuffer.h
index 70d4b56..24833fa 100644
--- a/include/outbuffer.h
+++ b/include/outbuffer.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  OutBuffer.h
  *
diff --git a/include/receivedframe.h b/include/receivedframe.h
index 0f9a0e4..03bd0ae 100644
--- a/include/receivedframe.h
+++ b/include/receivedframe.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  ReceivedFrame.h
  *
diff --git a/include/stringfield.h b/include/stringfield.h
index 1a2ffd3..724b495 100644
--- a/include/stringfield.h
+++ b/include/stringfield.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  String field types for amqp
  * 
diff --git a/include/table.h b/include/table.h
index 5343769..3435f13 100644
--- a/include/table.h
+++ b/include/table.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  AMQP field table
  * 
diff --git a/include/watchable.h b/include/watchable.h
index dab54aa..a81e71d 100644
--- a/include/watchable.h
+++ b/include/watchable.h
@@ -1,3 +1,4 @@
+#pragma once
 /**
  *  Watchable.h
  *

From 2939272bc8e189f221d36c3f485f512affde5002 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Tue, 8 Apr 2014 14:42:07 +0200
Subject: [PATCH 06/41] Work in progress to convert channel handler to callback
 system

---
 amqpcpp.h                        |   2 +
 include/callbacks.h              | 157 ++++++++++++++
 include/channel.h                | 360 ++++++++++++++++++------------
 include/channelhandler.h         | 126 +----------
 include/channelimpl.h            | 362 +++++++++++++++++--------------
 include/connection.h             |  18 ++
 include/connectionimpl.h         |  59 +++--
 include/deferred.h               | 179 +++++++++++++++
 src/basicqosokframe.h            |  16 +-
 src/basicrecoverokframe.h        |  16 +-
 src/channelflowokframe.h         |  13 +-
 src/channelimpl.cpp              | 298 ++++++++++++++++---------
 src/exchangebindokframe.h        |  20 +-
 src/exchangedeclareokframe.h     |  12 +-
 src/exchangedeleteokframe.h      |  14 +-
 src/exchangeunbindokframe.h      |  20 +-
 src/methodframe.h                |   5 +-
 src/queuebindokframe.h           |  12 +-
 src/queueunbindokframe.h         |  14 +-
 src/transactioncommitokframe.h   |  20 ++
 src/transactionrollbackokframe.h |  22 +-
 src/transactionselectokframe.h   |  20 ++
 22 files changed, 1137 insertions(+), 628 deletions(-)
 create mode 100644 include/callbacks.h
 create mode 100644 include/deferred.h

diff --git a/amqpcpp.h b/amqpcpp.h
index 3ae5c67..af79811 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -49,6 +49,8 @@
 // mid level includes
 #include <amqpcpp/exchangetype.h>
 #include <amqpcpp/flags.h>
+#include <amqpcpp/deferred.h>
+#include <amqpcpp/callbacks.h>
 #include <amqpcpp/channelhandler.h>
 #include <amqpcpp/channelimpl.h>
 #include <amqpcpp/channel.h>
diff --git a/include/callbacks.h b/include/callbacks.h
new file mode 100644
index 0000000..b29bb38
--- /dev/null
+++ b/include/callbacks.h
@@ -0,0 +1,157 @@
+/**
+ *  Callbacks.h
+ *
+ *  Class storing deferred callbacks of different type.
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  Class for managing deferred callbacks
+ */
+class Callbacks
+{
+private:
+    /**
+     *  Different callback types supported
+     */
+    std::tuple<
+        std::deque<Deferred<>>,
+        std::deque<Deferred<const std::string&, uint32_t, uint32_t>>,
+        std::deque<Deferred<uint32_t>>
+    > _callbacks;
+
+    /**
+     *  If all else fails, we have gotten the wrong
+     *  type, which is not present in the arguments.
+     *
+     *  This should result in a compile error.
+     */
+    template <class T, std::size_t N, class... Arguments>
+    struct getIndex
+    {
+        // if this structure is used, we went past the last argument
+        // and this static_assert should trigger a compile failure.
+        static_assert(N < sizeof...(Arguments), "Type T not found in Arguments");
+
+        // we still have to provide this member though
+        static constexpr std::size_t value = N;
+    };
+
+    /**
+     *  This structure has one static member that represents
+     *  the index of T in Arguments. This variant is used where U
+     *  does equal T, so a match is found, meaning the current
+     *  index given is the right one.
+     */
+    template <class T, std::size_t N, class... Arguments>
+    struct getIndex<T, N, T, Arguments...>
+    {
+        // element is same type as we are looking for
+        static constexpr std::size_t value = N;
+    };
+
+    /**
+     *  This structure has one static member that represents
+     *  the index of T in Arguments. This variant is used where U
+     *  does not equal T, so we need to look at the next member.
+     */
+    template <class T, std::size_t N, class U, class... Arguments>
+    struct getIndex<T, N, U, Arguments...>
+    {
+        // current N is not correct, unroll to next element
+        static constexpr std::size_t value = getIndex<T, N + 1, Arguments...>::value;
+    };
+
+    /**
+     *  Retrieve the list of callbacks matching the type
+     *
+     *  @param  tuple   tuple with callbacks
+     */
+    template <class T, class... Arguments>
+    T& get(std::tuple<Arguments...>& tuple)
+    {
+        // retrieve the index at which the requested callbacks can be found
+        constexpr std::size_t index = getIndex<T, 0, Arguments...>::value;
+
+        // retrieve the callbacks
+        return std::get<index>(tuple);
+    }
+public:
+    /**
+     *  Add a deferred to the available callbacks
+     *
+     *  @param  deferred    the deferred to add
+     *  @return reference to the inserted deferred
+     */
+    template <typename... Arguments>
+    Deferred<Arguments...>& push_back(const Deferred<Arguments...>& item)
+    {
+        // retrieve the container
+        auto &container = get<std::deque<Deferred<Arguments...>>>(_callbacks);
+
+        // add the element
+        container.push_back(item);
+
+        // return reference to the new item
+        return container.back();
+    }
+
+    /**
+     *  Report success to the relevant callback
+     *
+     *  @param  mixed...    additional parameters
+     */
+    template <typename... Arguments>
+    void reportSuccess(Arguments ...parameters)
+    {
+        // retrieve the container and element
+        auto &container = get<std::deque<Deferred<Arguments...>>>(_callbacks);
+        auto &callback  = container.front();
+
+        // execute the callback
+        callback.success(parameters...);
+
+        // remove the executed callback
+        container.pop_front();
+    }
+
+    /**
+     *  Report a failure
+     *
+     *  @param  error   a description of the error
+     */
+    template <std::size_t N = 0>
+    typename std::enable_if<N == std::tuple_size<decltype(_callbacks)>::value>::type
+    reportFailure(const std::string& message)
+    {}
+
+    /**
+     *  Report a failure
+     *
+     *  @param  error   a description of the error
+     */
+    template <std::size_t N = 0>
+    typename std::enable_if<N < std::tuple_size<decltype(_callbacks)>::value>::type
+    reportFailure(const std::string& message)
+    {
+        // retrieve the callbacks at current index
+        auto &callbacks = std::get<N>(_callbacks);
+
+        // report errors to all callbacks of the current type
+        for (auto &callback : callbacks) callback.error(message);
+
+        // execute the next type
+        reportFailure<N + 1>(message);
+    }
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/include/channel.h b/include/channel.h
index d9dae3e..8a2550a 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -1,7 +1,7 @@
 #pragma once
 /**
  *  Class describing a (mid-level) AMQP channel implementation
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -36,27 +36,55 @@ public:
     virtual ~Channel() {}
 
     /**
-     *  Pause deliveries on a channel
-     * 
-     *  This will stop all incoming messages
-     *  
-     *  This method returns true if the request to pause has been sent to the
-     *  broker. This does not necessarily mean that the channel is already
-     *  paused. 
-     * 
-     *  @return bool
+     *  Callback that is called when the channel was succesfully created.
+     *
+     *  Only one callback can be registered. Calling this function multiple
+     *  times will remove the old callback.
+     *
+     *  @param  callback    the callback to execute
      */
-    bool pause()
+    void onReady(const std::function<void(Channel *channel)>& callback)
+    {
+        // store callback in implementation
+        _implementation._readyCallback = callback;
+    }
+
+    /**
+     *  Callback that is called when an error occurs.
+     *
+     *  Only one error callback can be registered. Calling this function
+     *  multiple times will remove the old callback.
+     *
+     *  @param  callback    the callback to execute
+     */
+    void onError(const std::function<void(Channel *channel, const std::string& message)>& callback)
+    {
+        // store callback in implementation
+        _implementation._errorCallback = callback;
+    }
+
+    /**
+     *  Pause deliveries on a channel
+     *
+     *  This will stop all incoming messages
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     */
+    Deferred<>& pause()
     {
         return _implementation.pause();
     }
-    
+
     /**
      *  Resume a paused channel
-     * 
-     *  @return bool
+     *
+     *  This will resume incoming messages
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool resume()
+    Deferred<>& resume()
     {
         return _implementation.resume();
     }
@@ -69,199 +97,254 @@ public:
     {
         return _implementation.connected();
     }
-    
+
     /**
      *  Start a transaction
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool startTransaction()
+    Deferred<>& startTransaction()
     {
         return _implementation.startTransaction();
     }
-    
+
     /**
      *  Commit the current transaction
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool commitTransaction()
+    Deferred<>& commitTransaction()
     {
         return _implementation.commitTransaction();
     }
-    
+
     /**
      *  Rollback the current transaction
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool rollbackTransaction()
+    Deferred<>& rollbackTransaction()
     {
         return _implementation.rollbackTransaction();
     }
-    
+
     /**
      *  Declare an exchange
-     *  
+     *
      *  If an empty name is supplied, a name will be assigned by the server.
-     * 
+     *
      *  The following flags can be used for the exchange:
-     *  
+     *
      *      -   durable     exchange survives a broker restart
      *      -   autodelete  exchange is automatically removed when all connected queues are removed
      *      -   passive     only check if the exchange exist
-     * 
+     *
      *  @param  name        name of the exchange
      *  @param  type        exchange type
      *  @param  flags       exchange flags
      *  @param  arguments   additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(name, type, flags, arguments); }
-    bool declareExchange(const std::string &name, ExchangeType type, const Table &arguments) { return _implementation.declareExchange(name, type, 0, arguments); }
-    bool declareExchange(const std::string &name, ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(name, type, flags, Table()); }
-    bool declareExchange(ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(std::string(), type, flags, arguments); }
-    bool declareExchange(ExchangeType type, const Table &arguments) { return _implementation.declareExchange(std::string(), type, 0, arguments); }
-    bool declareExchange(ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(std::string(), type, flags, Table()); }
-    
+    Deferred<>& declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(name, type, flags, arguments); }
+    Deferred<>& declareExchange(const std::string &name, ExchangeType type, const Table &arguments) { return _implementation.declareExchange(name, type, 0, arguments); }
+    Deferred<>& declareExchange(const std::string &name, ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(name, type, flags, Table()); }
+    Deferred<>& declareExchange(ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(std::string(), type, flags, arguments); }
+    Deferred<>& declareExchange(ExchangeType type, const Table &arguments) { return _implementation.declareExchange(std::string(), type, 0, arguments); }
+    Deferred<>& declareExchange(ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(std::string(), type, flags, Table()); }
+
     /**
      *  Remove an exchange
-     * 
+     *
      *  The following flags can be used for the exchange:
-     *  
+     *
      *      -   ifunused    only delete if no queues are connected
 
      *  @param  name        name of the exchange to remove
      *  @param  flags       optional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool removeExchange(const std::string &name, int flags = 0) { return _implementation.removeExchange(name, flags); }
-    
+    Deferred<>& removeExchange(const std::string &name, int flags = 0) { return _implementation.removeExchange(name, flags); }
+
     /**
      *  Bind two exchanges to each other
-     * 
+     *
      *  The following flags can be used for the exchange
-     * 
+     *
      *      -   nowait      do not wait on response
-     * 
+     *
      *  @param  source      the source exchange
      *  @param  target      the target exchange
      *  @param  routingkey  the routing key
      *  @param  flags       optional flags
      *  @param  arguments   additional bind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, flags, arguments); }
-    bool bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, 0, arguments); }
-    bool bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags = 0) { return _implementation.bindExchange(source, target, routingkey, flags, Table()); }
-    
+    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, flags, arguments); }
+    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, 0, arguments); }
+    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags = 0) { return _implementation.bindExchange(source, target, routingkey, flags, Table()); }
+
     /**
      *  Unbind two exchanges from one another
-     * 
+     *
      *  The following flags can be used for the exchange
-     * 
+     *
      *      -   nowait      do not wait on response
-     * 
+     *
      *  @param  target      the target exchange
      *  @param  source      the source exchange
      *  @param  routingkey  the routing key
      *  @param  flags       optional flags
      *  @param  arguments   additional unbind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, flags, arguments); }
-    bool unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, 0, arguments); }
-    bool unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags = 0) { return _implementation.unbindExchange(target, source, routingkey, flags, Table()); }
-    
+    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, flags, arguments); }
+    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, 0, arguments); }
+    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags = 0) { return _implementation.unbindExchange(target, source, routingkey, flags, Table()); }
+
     /**
      *  Declare a queue
-     * 
+     *
      *  If you do not supply a name, a name will be assigned by the server.
-     * 
+     *
      *  The flags can be a combination of the following values:
-     * 
+     *
      *      -   durable     queue survives a broker restart
      *      -   autodelete  queue is automatically removed when all connected consumers are gone
      *      -   passive     only check if the queue exist
      *      -   exclusive   the queue only exists for this connection, and is automatically removed when connection is gone
-     *    
+     *
      *  @param  name        name of the queue
      *  @param  flags       combination of flags
      *  @param  arguments   optional arguments
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount) {
+     *
+     *      std::cout << "Queue '" << name << "' has been declared with " << messageCount << " messages and " << consumerCount << " consumers" << std::endl;
+     *
+     *  });
      */
-    bool declareQueue(const std::string &name, int flags, const Table &arguments) { return _implementation.declareQueue(name, flags, arguments); }
-    bool declareQueue(const std::string &name, const Table &arguments) { return _implementation.declareQueue(name, 0, arguments); }
-    bool declareQueue(const std::string &name, int flags = 0) { return _implementation.declareQueue(name, flags, Table()); }
-    bool declareQueue(int flags, const Table &arguments) { return _implementation.declareQueue(std::string(), flags, arguments); }
-    bool declareQueue(const Table &arguments) { return _implementation.declareQueue(std::string(), 0, arguments); }
-    bool declareQueue(int flags = 0) { return _implementation.declareQueue(std::string(), flags, Table()); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments) { return _implementation.declareQueue(name, flags, arguments); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, const Table &arguments) { return _implementation.declareQueue(name, 0, arguments); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags = 0) { return _implementation.declareQueue(name, flags, Table()); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags, const Table &arguments) { return _implementation.declareQueue(std::string(), flags, arguments); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const Table &arguments) { return _implementation.declareQueue(std::string(), 0, arguments); }
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags = 0) { return _implementation.declareQueue(std::string(), flags, Table()); }
 
     /**
      *  Bind a queue to an exchange
-     *  
+     *
      *  The following flags can be used for the exchange
-     * 
+     *
      *      -   nowait      do not wait on response
-     * 
+     *
      *  @param  exchange    the source exchange
      *  @param  queue       the target queue
      *  @param  routingkey  the routing key
      *  @param  flags       additional flags
      *  @param  arguments   additional bind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, flags, arguments); }
-    bool bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, 0, arguments); }
-    bool bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags = 0) { return _implementation.bindQueue(exchange, queue, routingkey, flags, Table()); }
-    
+    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, flags, arguments); }
+    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, 0, arguments); }
+    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags = 0) { return _implementation.bindQueue(exchange, queue, routingkey, flags, Table()); }
+
     /**
      *  Unbind a queue from an exchange
      *  @param  exchange    the source exchange
      *  @param  queue       the target queue
      *  @param  routingkey  the routing key
      *  @param  arguments   additional bind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) {  return _implementation.unbindQueue(exchange, queue, routingkey, arguments); }
-    bool unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey) { return _implementation.unbindQueue(exchange, queue, routingkey, Table()); }
-    
+    Deferred<>& unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) {  return _implementation.unbindQueue(exchange, queue, routingkey, arguments); }
+    Deferred<>& unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey) { return _implementation.unbindQueue(exchange, queue, routingkey, Table()); }
+
     /**
      *  Purge a queue
-     * 
+     *
      *  The following flags can be used for the exchange
-     * 
+     *
      *      -   nowait      do not wait on response
-     * 
+     *
      *  @param  name        name of the queue
      *  @param  flags       additional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+     *
+     *      std::cout << "Queue purged, all " << messageCount << " messages removed" << std::endl;
+     *
+     *  });
      */
-    bool purgeQueue(const std::string &name, int flags = 0){ return _implementation.purgeQueue(name, flags); }
-    
+    Deferred<uint32_t>& purgeQueue(const std::string &name, int flags = 0){ return _implementation.purgeQueue(name, flags); }
+
     /**
      *  Remove a queue
-     * 
+     *
      *  The following flags can be used for the exchange:
-     *  
+     *
      *      -   ifunused    only delete if no consumers are connected
      *      -   ifempty     only delete if the queue is empty
      *
      *  @param  name        name of the queue to remove
      *  @param  flags       optional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+     *
+     *      std::cout << "Queue deleted, along with " << messageCount << " messages" << std::endl;
+     *
+     *  });
      */
-    bool removeQueue(const std::string &name, int flags = 0) { return _implementation.removeQueue(name, flags); }
-    
+    Deferred<uint32_t>& removeQueue(const std::string &name, int flags = 0) { return _implementation.removeQueue(name, flags); }
+
     /**
      *  Publish a message to an exchange
-     * 
+     *
      *  The following flags can be used
-     * 
+     *
      *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
      *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
-     * 
+     *
      *  If either of the two flags is set, and the message could not immediately
      *  be published, the message is returned by the server to the client. If you
-     *  want to catch such returned messages, you need to implement the 
+     *  want to catch such returned messages, you need to implement the
      *  ChannelHandler::onReturned() method.
-     * 
+     *
      *  @param  exchange    the exchange to publish to
      *  @param  routingkey  the routing key
      *  @param  flags       optional flags (see above)
@@ -275,44 +358,44 @@ public:
     bool publish(const std::string &exchange, const std::string &routingKey, const std::string &message) { return _implementation.publish(exchange, routingKey, 0, Envelope(message)); }
     bool publish(const std::string &exchange, const std::string &routingKey, int flags, const char *message, size_t size) { return _implementation.publish(exchange, routingKey, flags, Envelope(message, size)); }
     bool publish(const std::string &exchange, const std::string &routingKey, const char *message, size_t size) { return _implementation.publish(exchange, routingKey, 0, Envelope(message, size)); }
-    
+
     /**
      *  Set the Quality of Service (QOS) for this channel
-     * 
-     *  When you consume messages, every single messages needs to be ack'ed to inform
+     *
+     *  When you consume messages, every single message needs to be ack'ed to inform
      *  the RabbitMQ server that is has been received. The Qos setting specifies the
      *  number of unacked messages that may exist in the client application. The server
      *  stops delivering more messages if the number of unack'ed messages has reached
      *  the prefetchCount
-     * 
+     *
      *  @param  prefetchCount       maximum number of messages to prefetch
      *  @return bool                whether the Qos frame is sent.
      */
-    bool setQos(uint16_t prefetchCount)
+    Deferred<>& setQos(uint16_t prefetchCount)
     {
         return _implementation.setQos(prefetchCount);
     }
-    
+
     /**
      *  Tell the RabbitMQ server that we're ready to consume messages
-     * 
+     *
      *  After this method is called, RabbitMQ starts delivering messages to the client
      *  application. The consume tag is a string identifier that will be passed to
-     *  each received message, so that you can associate incoming messages with a 
+     *  each received message, so that you can associate incoming messages with a
      *  consumer. If you do not specify a consumer tag, the server will assign one
      *  for you.
-     * 
+     *
      *  The following flags are supported:
-     * 
+     *
      *      -   nolocal             if set, messages published on this channel are not also consumed
      *      -   noack               if set, consumed messages do not have to be acked, this happens automatically
      *      -   exclusive           request exclusive access, only this consumer can access the queue
      *      -   nowait              the server does not have to send a response back that consuming is active
-     * 
-     *  The method ChannelHandler::onConsumerStarted() will be called when the 
+     *
+     *  The method ChannelHandler::onConsumerStarted() will be called when the
      *  consumer has started (unless the nowait option was set, in which case
      *  no confirmation method is called)
-     * 
+     *
      *  @param  queue               the queue from which you want to consume
      *  @param  tag                 a consumer tag that will be associated with this consume operation
      *  @param  flags               additional flags
@@ -325,56 +408,56 @@ public:
     bool consume(const std::string &queue, int flags, const Table &arguments) { return _implementation.consume(queue, std::string(), flags, arguments); }
     bool consume(const std::string &queue, int flags = 0) { return _implementation.consume(queue, std::string(), flags, Table()); }
     bool consume(const std::string &queue, const Table &arguments) { return _implementation.consume(queue, std::string(), 0, arguments); }
-    
+
     /**
      *  Cancel a running consume call
-     * 
+     *
      *  If you want to stop a running consumer, you can use this method with the consumer tag
-     * 
+     *
      *  The following flags are supported:
-     * 
+     *
      *      -   nowait              the server does not have to send a response back that the consumer has been cancelled
-     * 
+     *
      *  The method ChannelHandler::onConsumerStopped() will be called when the consumer
      *  was succesfully stopped (unless the nowait option was used, in which case no
      *  confirmation method is called)
-     * 
+     *
      *  @param  tag                 the consumer tag
      *  @param  flags               optional additional flags
      *  @return bool
      */
     bool cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
-    
+
     /**
      *  Acknoldge a received message
-     * 
+     *
      *  When a message is received in the ChannelHandler::onReceived() method,
      *  you must acknoledge it so that RabbitMQ removes it from the queue (unless
      *  you are consuming with the noack option). This method can be used for
      *  this acknoledging.
-     * 
+     *
      *  The following flags are supported:
-     * 
+     *
      *      -   multiple            acknoledge multiple messages: all un-acked messages that were earlier delivered are acknowledged too
-     * 
+     *
      *  @param  deliveryTag         the unique delivery tag of the message
      *  @param  flags               optional flags
      *  @return bool
      */
     bool ack(uint64_t deliveryTag, int flags=0) { return _implementation.ack(deliveryTag, flags); }
-    
+
     /**
      *  Reject or nack a message
-     * 
+     *
      *  When a message was received in the ChannelHandler::onReceived() method,
      *  and you don't want to acknoledge it, you can also choose to reject it by
-     *  calling this reject method. 
-     * 
+     *  calling this reject method.
+     *
      *  The following flags are supported:
-     * 
+     *
      *      -   multiple            reject multiple messages: all un-acked messages that were earlier delivered are unacked too
      *      -   requeue             if set, the message is put back in the queue, otherwise it is dead-lettered/removed
-     * 
+     *
      *  @param  deliveryTag         the unique delivery tag of the message
      *  @param  flags               optional flags
      *  @return bool
@@ -383,27 +466,28 @@ public:
 
     /**
      *  Recover all messages that were not yet acked
-     * 
-     *  This method asks the server to redeliver all unacknowledged messages on a specified 
+     *
+     *  This method asks the server to redeliver all unacknowledged messages on a specified
      *  channel. Zero or more messages may be redelivered.
-     * 
+     *
      *  The following flags are supported:
-     * 
+     *
      *      -   requeue             if set, the server will requeue the messages, so the could also end up with at different consumer
-     * 
+     *
      *  @param  flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool recover(int flags = 0) { return _implementation.recover(flags); }
+    Deferred<>& recover(int flags = 0) { return _implementation.recover(flags); }
 
     /**
      *  Close the current channel
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool close()
-    {
-        return _implementation.close();
-    }
+    Deferred<>& close() { return _implementation.close(); }
 
     /**
      *  Get the channel we're working on
diff --git a/include/channelhandler.h b/include/channelhandler.h
index c0d3438..2ad468f 100644
--- a/include/channelhandler.h
+++ b/include/channelhandler.h
@@ -22,12 +22,6 @@ namespace AMQP {
 class ChannelHandler
 {
 public:
-    /**
-     *  Method that is called when the channel was succesfully created.
-     *  @param  channel         the channel that is ready
-     */
-    virtual void onReady(Channel *channel) {}
-    
     /**
      *  An error has occured on the channel
      *  The channel is no longer usable after an error has occured on it.
@@ -36,108 +30,6 @@ public:
      */
     virtual void onError(Channel *channel, const std::string &message) {}
 
-    /**
-     *  Method that is called when the channel was paused
-     *  This is the result of a call to Channel::pause()
-     *  @param  channel         the channel that is now paused
-     */
-    virtual void onPaused(Channel *channel) {}
-    
-    /**
-     *  Method that is called when the channel was resumed
-     *  This is the result of a call to Channel::resume()
-     *  @param  channel         the channel that is no longer paused
-     */
-    virtual void onResumed(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a channel is closed
-     *  This is the result of a call to Channel::close()
-     *  @param  channel         the channel that is closed
-     */
-    virtual void onClosed(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a transaction was started
-     *  This is the result of a call to Channel::startTransaction()
-     *  @param  channel         the channel on which the transaction was started
-     */
-    virtual void onTransactionStarted(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a transaction was committed
-     *  This is the result of a call to Channel::commitTransaction()
-     *  @param  channel         the channel on which the transaction was committed
-     */
-    virtual void onTransactionCommitted(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a transaction was rolled back
-     *  This is the result of a call to Channel::rollbackTransaction()
-     *  @param  channel         the channel on which the transaction was rolled back
-     */
-    virtual void onTransactionRolledBack(Channel *channel) {}
-    
-    /**
-     *  Method that is called when an exchange is bound
-     *  This is the result of a call to Channel::bindExchange()
-     *  @param  channel         the channel on which the exchange was bound
-     */
-    virtual void onExchangeBound(Channel *channel) {}
-    
-    /**
-     *  Method that is called when an exchange is unbound
-     *  This is the result of a call to Channel::unbindExchange()
-     *  @param  channel         the channel on which the exchange was unbound
-     */
-    virtual void onExchangeUnbound(Channel *channel) {}     
-    
-    /**
-     *  Method that is called when an exchange is deleted
-     *  This is the result of a call to Channel::deleteExchange()
-     *  @param  channel         the channel on which the exchange was deleted
-     */
-    virtual void onExchangeDeleted(Channel *channel) {}
-    
-    /**
-     *  Mehod that is called when an exchange is declared
-     *  This is the result of a call to Channel::declareExchange()
-     *  @param  channel         the channel on which the exchange was declared
-     */
-    virtual void onExchangeDeclared(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a queue is declared
-     *  This is the result of a call to Channel::declareQueue()
-     *  @param  channel         the channel on which the queue was declared
-     *  @param  name            name of the queue
-     *  @param  messageCount    number of messages in queue
-     *  @param  consumerCount   number of active consumers
-     */
-    virtual void onQueueDeclared(Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount) {}
-    
-    /**
-     *  Method that is called when a queue is bound
-     *  This is the result of a call to Channel::bindQueue()
-     *  @param  channel         the channel on which the queue was bound
-     */
-    virtual void onQueueBound(Channel *channel) {}
-    
-    /**
-     *  Method that is called when a queue is deleted
-     *  This is the result of a call to Channel::deleteQueue()
-     *  @param  channel         the channel on which the queue was deleted
-     *  @param  messageCount    number of messages deleted along with the queue
-     */
-    virtual void onQueueDeleted(Channel *channel, uint32_t messageCount) {}
-    
-    /**
-     *  Method that is called when a queue is unbound
-     *  This is the result of a call to Channel::unbindQueue()
-     *  @param  channel         the channel on which the queue was unbound
-     */
-    virtual void onQueueUnbound(Channel *channel) {}
-    
     /**
      *  Method that is called when a queue is purged
      *  This is the result of a call to Channel::purgeQueue()
@@ -146,13 +38,6 @@ public:
      */
     virtual void onQueuePurged(Channel *channel, uint32_t messageCount) {}
 
-    /**
-     *  Method that is called when the quality-of-service was changed
-     *  This is the result of a call to Channel::setQos()
-     *  @param  channel         the channel on which the qos was set
-     */
-    virtual void onQosSet(Channel *channel) {}
-    
     /**
      *  Method that is called when a consumer was started
      *  This is the result of a call to Channel::consume()
@@ -168,7 +53,7 @@ public:
      *  @param  tag             the consumer tag
      */
     virtual void onConsumerStopped(Channel *channel, const std::string &tag) {}
-    
+
     /**
      *  Method that is called when a message has been received on a channel
      *  This message will be called for every message that is received after
@@ -182,7 +67,7 @@ public:
      *  @param  redelivered     is this a redelivered message?
      */
     virtual void onReceived(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {}
-    
+
     /**
      *  Method that is called when a message you tried to publish was returned
      *  by the server. This only happens when the 'mandatory' or 'immediate' flag
@@ -193,13 +78,6 @@ public:
      *  @param  text            human readable reply reason
      */
     virtual void onReturned(Channel *channel, const Message &message, int16_t code, const std::string &text) {}
-    
-    /**
-     *  Method that is called when the server starts recovering messages
-     *  This is the result of a call to Channel::recover()
-     *  @param  channel         the channel on which the recover method was called
-     */
-    virtual void onRecovering(Channel *channel) {}
 
 };
 
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 77e4f16..6651e9b 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -37,7 +37,28 @@ private:
      *  @var    MyChannelHandler
      */
     ChannelHandler *_handler;
-    
+
+    /**
+     *  Callback when the channel is ready
+     */
+    std::function<void(Channel *channel)> _readyCallback;
+
+    /**
+     *  Callback when the channel errors out
+     */
+    std::function<void(Channel *channel, const std::string& message)> _errorCallback;
+
+    /**
+     *  The callbacks waiting to be called
+     */
+    std::deque<Deferred<>> _callbacks;
+
+    /**
+     *  Callbacks with additional parameters
+     */
+    std::deque<Deferred<const std::string&, uint32_t, uint32_t>> _queueDeclaredCallbacks;
+    std::deque<Deferred<uint32_t>> _queueRemovedCallbacks;
+
     /**
      *  The channel number
      *  @var uint16_t
@@ -53,13 +74,13 @@ private:
         state_closing,
         state_closed
     } _state = state_connected;
-    
+
     /**
      *  Is a transaction now active?
      *  @var bool
      */
     bool _transaction = false;
-    
+
     /**
      *  The message that is now being received
      *  @var MessageImpl
@@ -68,11 +89,11 @@ private:
 
     /**
      *  Construct a channel object
-     *  
+     *
      *  Note that the constructor is private, and that the Channel class is
      *  a friend. By doing this we ensure that nobody can instantiate this
      *  object, and that it can thus only be used inside the library.
-     * 
+     *
      *  @param  parent          the public channel object
      *  @param  connection      pointer to the connection
      *  @param  handler         handler that is notified on events
@@ -96,23 +117,23 @@ public:
 
     /**
      *  Pause deliveries on a channel
-     * 
+     *
      *  This will stop all incoming messages
-     *  
-     *  This method returns true if the request to pause has been sent to the
-     *  broker. This does not necessarily mean that the channel is already
-     *  paused. 
-     * 
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool pause();
-    
+    Deferred<>& pause();
+
     /**
      *  Resume a paused channel
-     * 
-     *  @return bool
+     *
+     *  This will resume incoming messages
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool resume();
+    Deferred<>& resume();
 
     /**
      *  Is the channel connected?
@@ -122,123 +143,170 @@ public:
     {
         return _state == state_connected;
     }
-    
+
     /**
      *  Start a transaction
-     *  @return bool
      */
-    bool startTransaction();
-    
+    Deferred<>& startTransaction();
+
     /**
      *  Commit the current transaction
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool commitTransaction();
-    
+    Deferred<>& commitTransaction();
+
     /**
      *  Rollback the current transaction
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool rollbackTransaction();
-    
+    Deferred<>& rollbackTransaction();
+
     /**
      *  declare an exchange
+     *
      *  @param  name        name of the exchange to declare
      *  @param  type        type of exchange
      *  @param  flags       additional settings for the exchange
      *  @param  arguments   additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments);
-    
+    Deferred<>& declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments);
+
     /**
      *  bind two exchanges
+
      *  @param  source      exchange which binds to target
      *  @param  target      exchange to bind to
      *  @param  routingKey  routing key
      *  @param  glags       additional flags
      *  @param  arguments   additional arguments for binding
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
-    
+    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+
     /**
      *  unbind two exchanges
+
      *  @param  source      the source exchange
      *  @param  target      the target exchange
      *  @param  routingkey  the routing key
      *  @param  flags       optional flags
      *  @param  arguments   additional unbind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
-    
+    Deferred<>& unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+
     /**
      *  remove an exchange
+     *
      *  @param  name        name of the exchange to remove
      *  @param  flags       additional settings for deleting the exchange
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool removeExchange(const std::string &name, int flags);
-    
+    Deferred<>& removeExchange(const std::string &name, int flags);
+
     /**
      *  declare a queue
      *  @param  name        queue name
      *  @param  flags       additional settings for the queue
      *  @param  arguments   additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool declareQueue(const std::string &name, int flags, const Table &arguments);
-    
+    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments);
+
     /**
      *  Bind a queue to an exchange
+     *
      *  @param  exchangeName    name of the exchange to bind to
      *  @param  queueName       name of the queue
      *  @param  routingkey      routingkey
      *  @param  flags           additional flags
      *  @param  arguments       additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred<>& bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments);
 
     /**
      *  Unbind a queue from an exchange
+     *
      *  @param  exchange    the source exchange
      *  @param  queue       the target queue
      *  @param  routingkey  the routing key
      *  @param  arguments   additional bind arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool unbindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments);
-    
+    Deferred<>& unbindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments);
+
     /**
      *  Purge a queue
      *  @param  queue       queue to purge
      *  @param  flags       additional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+     *
+     *      std::cout << "Queue purged, all " << messageCount << " messages removed" << std::endl;
+     *
+     *  });
      */
-    bool purgeQueue(const std::string &name, int flags);
-    
+    Deferred<uint32_t>& purgeQueue(const std::string &name, int flags);
+
     /**
      *  Remove a queue
      *  @param  queue       queue to remove
      *  @param  flags       additional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+     *
+     *      std::cout << "Queue deleted, along with " << messageCount << " messages" << std::endl;
+     *
+     *  });
      */
-    bool removeQueue(const std::string &name, int flags);
+    Deferred<uint32_t>& removeQueue(const std::string &name, int flags);
 
     /**
      *  Publish a message to an exchange
-     * 
+     *
      *  The following flags can be used
-     * 
+     *
      *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
      *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
-     * 
+     *
      *  If the mandatory or immediate flag is set, and the message could not immediately
      *  be published, the message will be returned to the client, and will eventually
      *  end up in your ChannelHandler::onReturned() method.
-     * 
+     *
      *  @param  exchange    the exchange to publish to
      *  @param  routingkey  the routing key
      *  @param  flags       optional flags (see above)
@@ -247,13 +315,15 @@ public:
      *  @param  size        size of the message
      */
     bool publish(const std::string &exchange, const std::string &routingKey, int flags, const Envelope &envelope);
-    
+
     /**
      *  Set the Quality of Service (QOS) of the entire connection
      *  @param  prefetchCount       maximum number of messages to prefetch
-     *  @return bool                whether the Qos frame is sent.
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool setQos(uint16_t prefetchCount);
+    Deferred<>& setQos(uint16_t prefetchCount);
 
     /**
      *  Tell the RabbitMQ server that we're ready to consume messages
@@ -264,7 +334,7 @@ public:
      *  @return bool
      */
     bool consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments);
-    
+
     /**
      *  Cancel a running consumer
      *  @param  tag                 the consumer tag
@@ -288,19 +358,23 @@ public:
      *  @return bool
      */
     bool reject(uint64_t deliveryTag, int flags);
-    
+
     /**
      *  Recover messages that were not yet ack'ed
      *  @param  flags               optional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool recover(int flags);
-    
+    Deferred<>& recover(int flags);
+
     /**
      *  Close the current channel
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
      */
-    bool close();
+    Deferred<>& close();
 
     /**
      *  Get the channel we're working on
@@ -310,14 +384,34 @@ public:
     {
         return _id;
     }
-    
+
     /**
      *  Send a frame over the channel
      *  @param  frame       frame to send
      *  @return bool        was frame succesfully sent?
      */
     bool send(const Frame &frame);
-    
+
+    /**
+     *  Send a frame over the channel and
+     *  get a deferred handler for it.
+     *
+     *  @param  frame       frame to send
+     *  @param  message     the message to trigger if the frame cannot be send at all
+     */
+    Deferred<>& send(const Frame &frame, const char *message);
+
+    /**
+     *  Send a frame over the channel and
+     *  get a deferred handler for it.
+     *
+     *  @param  frame       frame to send
+     *  @param  message     the message to trigger if the frame cannot be send at all
+     *  @param  queue       the queue to store the callbacks in
+     */
+    template <typename... Arguments>
+    Deferred<Arguments...>& send(const Frame &frame, const char *message, std::deque<Deferred<Arguments...>>& queue);
+
     /**
      *  Report to the handler that the channel is closed
      */
@@ -325,38 +419,33 @@ public:
     {
         // change state
         _state = state_closed;
-        
+
         // inform handler
-        if (_handler) _handler->onClosed(_parent);
+        reportSuccess();
     }
-    
+
     /**
-     *  Report to the handler that the channel is paused
+     *  Report success
+     *
+     *  This function is called to report success for all
+     *  cases where the callback does not receive any parameters
      */
-    void reportPaused()
+    void reportSuccess()
     {
-        // inform handler
-        if (_handler) _handler->onPaused(_parent);
+        // report success for the oldest request
+        _callbacks.front().success();
+        _callbacks.pop_front();
     }
-    
-    /**
-     *  Report to the handler that the channel is resumed
-     */
-    void reportResumed()
-    {
-        // inform handler
-        if (_handler) _handler->onResumed(_parent);
-    }
-    
+
     /**
      *  Report to the handler that the channel is opened
      */
     void reportReady()
     {
         // inform handler
-        if (_handler) _handler->onReady(_parent);
+        if (_readyCallback) _readyCallback(_parent);
     }
-    
+
     /**
      *  Report an error message on a channel
      *  @param  message
@@ -365,43 +454,16 @@ public:
     {
         // change state
         _state = state_closed;
-        
+
         // inform handler
-        if (_handler) _handler->onError(_parent, message);
+        if (_errorCallback) _errorCallback(_parent, message);
+
+        // and all waiting deferred callbacks
+        for (auto &deferred : _callbacks)               deferred.error(message);
+        for (auto &deferred : _queueDeclaredCallbacks)  deferred.error(message);
+        for (auto &deferred : _queueRemovedCallbacks)   deferred.error(message);
     }
 
-    /**
-     *  Report that the exchange is succesfully declared
-     */
-    void reportExchangeDeclared()
-    {
-        if (_handler) _handler->onExchangeDeclared(_parent);
-    }
-    
-    /**
-     *  Report that the exchange is succesfully deleted
-     */
-    void reportExchangeDeleted()
-    {
-        if (_handler) _handler->onExchangeDeleted(_parent);
-    }
-    
-    /**
-     *  Report that the exchange is bound
-     */
-    void reportExchangeBound()
-    {
-        if (_handler) _handler->onExchangeBound(_parent);
-    }
-    
-    /**
-     *  Report that the exchange is unbound
-     */
-    void reportExchangeUnbound()
-    {
-        if (_handler) _handler->onExchangeUnbound(_parent);
-    }
-    
     /**
      *  Report that the queue was succesfully declared
      *  @param  queueName       name of the queue which was declared
@@ -410,51 +472,33 @@ public:
      */
     void reportQueueDeclared(const std::string &queueName, uint32_t messageCount, uint32_t consumerCount)
     {
-        if (_handler) _handler->onQueueDeclared(_parent, queueName, messageCount, consumerCount);
+        // report success for the oldest queue declare callbacks
+        _queueDeclaredCallbacks.front().success(queueName, messageCount, consumerCount);
+        _queueDeclaredCallbacks.pop_front();
     }
-    
-    /**
-     *  Report that a queue was succesfully bound
-     */
-    void reportQueueBound()
-    {
-        if (_handler) _handler->onQueueBound(_parent);
-    }
-    
-    /**
-     *  Report that a queue was succesfully unbound
-     */
-    void reportQueueUnbound()
-    {
-        if (_handler) _handler->onQueueUnbound(_parent);
-    }
-    
+
     /**
      *  Report that a queue was succesfully deleted
      *  @param  messageCount    number of messages left in queue, now deleted
      */
     void reportQueueDeleted(uint32_t messageCount)
     {
-        if (_handler) _handler->onQueueDeleted(_parent, messageCount);
+        // report success for the oldest queue remove callbacks
+        _queueRemovedCallbacks.front().success(messageCount);
+        _queueRemovedCallbacks.pop_front();
     }
-    
+
     /**
      *  Report that a queue was succesfully purged
      *  @param  messageCount    number of messages purged
      */
     void reportQueuePurged(uint32_t messageCount)
     {
-        if (_handler) _handler->onQueuePurged(_parent, messageCount);
+        // report success for the oldest queue remove callbacks
+        _queueRemovedCallbacks.front().success(messageCount);
+        _queueRemovedCallbacks.pop_front();
     }
-    
-    /**
-     *  Report that the qos has been set
-     */
-    void reportQosSet()
-    {
-        if (_handler) _handler->onQosSet(_parent);
-    }
-    
+
     /**
      *  Report that a consumer has started
      *  @param  tag     the consumer tag
@@ -472,20 +516,12 @@ public:
     {
         if (_handler) _handler->onConsumerStopped(_parent, tag);
     }
-    
+
     /**
      *  Report that a message was received
      */
     void reportMessage();
 
-    /**
-     *  Report that the recover operation has started
-     */
-    void reportRecovering()
-    {
-        if (_handler) _handler->onRecovering(_parent);
-    }
-
     /**
      *  Create an incoming message
      *  @param  frame
@@ -493,7 +529,7 @@ public:
      */
     MessageImpl *message(const BasicDeliverFrame &frame);
     MessageImpl *message(const BasicReturnFrame &frame);
-    
+
     /**
      *  Retrieve the current incoming message
      *  @return MessageImpl
@@ -502,12 +538,12 @@ public:
     {
         return _message;
     }
-    
+
     /**
      *  The channel class is its friend, thus can it instantiate this object
      */
     friend class Channel;
-    
+
 };
 
 /**
diff --git a/include/connection.h b/include/connection.h
index a67e6ad..a5fed2b 100644
--- a/include/connection.h
+++ b/include/connection.h
@@ -22,6 +22,24 @@ private:
      */
     ConnectionImpl _implementation;
 
+    /**
+     *  Function to execute code after a certain timeout.
+     *
+     *  If the timeout is 0, the code is supposed to be run
+     *  in the next iteration of the event loop.
+     *
+     *  This is a simple placeholder function that will just
+     *  execute the code immediately, it should be overridden
+     *  by the timeout function the used event loop has.
+     *
+     *  @param  timeout     the amount of time to wait
+     *  @param  callback    the callback to execute after the timeout
+     */
+    std::function<void(double timeout, const std::function<void()>)> _timeoutHandler = [](double timeout, const std::function<void()>& callback) {
+        // execute callback immediately
+        callback();
+    };
+
 public:
     /**
      *  Construct an AMQP object based on full login data
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index 77adada..26f7f63 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -5,7 +5,7 @@
  *  This is the implementation of the connection - a class that can only be
  *  constructed by the connection class itselves and that has all sorts of
  *  methods that are only useful inside the library
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -44,13 +44,13 @@ protected:
         state_closing,              // connection is busy closing (we have sent the close frame)
         state_closed                // connection is closed
     } _state = state_protocol;
-    
+
     /**
      *  Has the close() method been called?
      *  @var    bool
      */
     bool _closed = false;
-    
+
     /**
      *  All channels that are active
      *  @var    map
@@ -62,13 +62,13 @@ protected:
      *  @var    uint16_t
      */
     uint16_t _nextFreeChannel = 1;
-    
+
     /**
      *  Max number of channels (0 for unlimited)
      *  @var    uint16_t
      */
     uint16_t _maxChannels = 0;
-    
+
     /**
      *  Max frame size
      *  @var    uint32_t
@@ -80,19 +80,19 @@ protected:
      *  @var    Login
      */
     Login _login;
-    
+
     /**
      *  Vhost to connect to
      *  @var    string
      */
     std::string _vhost;
-    
+
     /**
      *  Queued messages that should be sent after the connection has been established
      *  @var    queue
      */
     std::queue<OutBuffer> _queue;
-    
+
     /**
      *  Helper method to send the close frame
      *  Return value tells if the connection is still valid
@@ -100,17 +100,16 @@ protected:
      */
     bool sendClose();
 
-
 private:
     /**
      *  Construct an AMQP object based on full login data
-     * 
+     *
      *  The first parameter is a handler object. This handler class is
      *  an interface that should be implemented by the caller.
-     * 
+     *
      *  Note that the constructor is private to ensure that nobody can construct
      *  this class, only the real Connection class via a friend construct
-     * 
+     *
      *  @param  parent          Parent connection object
      *  @param  handler         Connection handler
      *  @param  login           Login data
@@ -132,7 +131,7 @@ public:
         // must be busy doing the connection handshake, or already connected
         return _state == state_handshake || _state == state_connected;
     }
-    
+
     /**
      *  Mark the protocol as being ok
      */
@@ -141,7 +140,7 @@ public:
         // move on to handshake state
         if (_state == state_protocol) _state = state_handshake;
     }
-    
+
     /**
      *  Are we fully connected?
      *  @return bool
@@ -151,12 +150,12 @@ public:
         // state must be connected
         return _state == state_connected;
     }
-    
+
     /**
      *  Mark the connection as connected
      */
     void setConnected();
-    
+
     /**
      *  Retrieve the login data
      *  @return Login
@@ -165,7 +164,7 @@ public:
     {
         return _login;
     }
-    
+
     /**
      *  Retrieve the vhost
      *  @return string
@@ -185,7 +184,7 @@ public:
         _maxChannels = channels;
         _maxFrame = size;
     }
-    
+
     /**
      *  The max frame size
      *  @return uint32_t
@@ -194,7 +193,7 @@ public:
     {
         return _maxFrame;
     }
-    
+
     /**
      *  The max payload size for body frames
      *  @return uint32_t
@@ -204,7 +203,7 @@ public:
         // 8 bytes for header and end-of-frame byte
         return _maxFrame - 8;
     }
-    
+
     /**
      *  Add a channel to the connection, and return the channel ID that it
      *  is allowed to use, or 0 when no more ID's are available
@@ -212,16 +211,16 @@ public:
      *  @return uint16_t
      */
     uint16_t add(ChannelImpl *channel);
-    
+
     /**
      *  Remove a channel
      *  @param  channel
      */
     void remove(ChannelImpl *channel);
-    
+
     /**
      *  Parse the buffer into a recognized frame
-     *  
+     *
      *  Every time that data comes in on the connection, you should call this method to parse
      *  the incoming data, and let it handle by the AMQP library. This method returns the number
      *  of bytes that were processed.
@@ -246,9 +245,9 @@ public:
 
     /**
      *  Send a frame over the connection
-     * 
+     *
      *  This is an internal method that you normally do not have to call yourself
-     * 
+     *
      *  @param  frame       the frame to send
      *  @return bool
      */
@@ -256,11 +255,11 @@ public:
 
     /**
      *  Get a channel by its identifier
-     * 
+     *
      *  This method only works if you had already created the channel before.
      *  This is an internal method that you will not need if you cache the channel
      *  object.
-     * 
+     *
      *  @param  number          channel identifier
      *  @return channel         the channel object, or nullptr if not yet created
      */
@@ -278,11 +277,11 @@ public:
     {
         // set connection state to closed
         _state = state_closed;
-        
+
         // inform handler
         _handler->onError(_parent, message);
     }
-    
+
     /**
      *  Report that the connection is closed
      */
@@ -290,7 +289,7 @@ public:
     {
         // change state
         _state = state_closed;
-        
+
         // inform the handler
         _handler->onClosed(_parent);
     }
diff --git a/include/deferred.h b/include/deferred.h
new file mode 100644
index 0000000..8e0e9a0
--- /dev/null
+++ b/include/deferred.h
@@ -0,0 +1,179 @@
+/**
+ *  Deferred.h
+ *
+ *  Class describing a set of actions that could
+ *  possibly happen in the future that can be
+ *  caught.
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+// forward declaration
+class ChannelImpl;
+
+/**
+ *  Class definition
+ */
+template <typename... Arguments>
+class Deferred
+{
+private:
+    /**
+     *  The channel we operate under
+     */
+    Channel *_channel;
+
+    /**
+     *  Do we already know we failed?
+     */
+    bool _failed;
+
+    /**
+     *  Callback to execute on success
+     */
+    std::function<void(Channel *channel, Arguments ...parameters)> _successCallback;
+
+    /**
+     *  Callback to execute on failure
+     */
+    std::function<void(Channel *channel, const std::string& error)> _errorCallback;
+
+    /**
+     *  Callback to execute either way
+     */
+    std::function<void(Channel *channel, const std::string& error)> _finalizeCallback;
+
+    /**
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+
+    /**
+     *  Indicate success
+     *
+     *  @param  parameters...   the extra parameters relevant for this deferred handler
+     */
+    void success(Arguments ...parameters)
+    {
+        // execute callbacks if registered
+        if (_successCallback)   _successCallback(_channel, parameters...);
+        if (_finalizeCallback)  _finalizeCallback(_channel, "");
+    }
+
+    /**
+     *  Indicate failure
+     *
+     *  @param  error   description of the error that occured
+     */
+    void error(const std::string& error)
+    {
+        // we are now in a failed state
+        _failed = true;
+
+        // execute callbacks if registered
+        if (_errorCallback)     _errorCallback(_channel, error);
+        if (_finalizeCallback)  _finalizeCallback(_channel, error);
+    }
+
+    /**
+     *  Private constructor that can only be called
+     *  from within the channel implementation
+     *
+     *  @param  channel the channel we operate under
+     *  @param  boolea  are we already failed?
+     */
+    Deferred(Channel *channel, bool failed = false) :
+        _channel(channel),
+        _failed(failed)
+    {}
+public:
+    /**
+     *  Deleted copy constructor
+     */
+    Deferred(const Deferred& that) = delete;
+
+    /**
+     *  Move constructor
+     */
+    Deferred(Deferred&& that) :
+        _successCallback(std::move(that._successCallback)),
+        _errorCallback(std::move(that._errorCallback)),
+        _finalizeCallback(std::move(that._finalizeCallback))
+    {}
+
+    /**
+     *  Cast to a boolean
+     */
+    operator bool ()
+    {
+        return !_failed;
+    }
+
+    /**
+     *  Register a function to be called
+     *  if and when the operation succesfully
+     *  completes.
+     *
+     *  Only one callback can be registered at a time.
+     *  Successive calls to this function will clear
+     *  callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    Deferred& onSuccess(const std::function<void(Channel *channel, Arguments ...parameters)>& callback)
+    {
+        // store callback
+        _successCallback = callback;
+        return *this;
+    }
+
+    /**
+     *  Register a function to be called
+     *  if and when the operation fails.
+     *
+     *  Only one callback can be registered at a time.
+     *  Successive calls to this function will clear
+     *  callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    Deferred& onError(const std::function<void(Channel *channel, const std::string& error)>& callback)
+    {
+        // store callback
+        _errorCallback = callback;
+        return *this;
+    }
+
+    /**
+     *  Register a function to be called
+     *  if and when the operation completes
+     *  or fails. This function will be called
+     *  either way.
+     *
+     *  In the case of success, the provided
+     *  error parameter will be an empty string.
+     *
+     *  Only one callback can be registered at at time.
+     *  Successive calls to this function will clear
+     *  callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    Deferred& onFinalize(const std::function<void(Channel *channel, const std::string& error)>& callback)
+    {
+        // store callback
+        _finalizeCallback = callback;
+        return *this;
+    }
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/src/basicqosokframe.h b/src/basicqosokframe.h
index 5d8bca1..dc6e612 100644
--- a/src/basicqosokframe.h
+++ b/src/basicqosokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a basic QOS frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -32,7 +32,7 @@ public:
      *  @param  channel     channel we're working on
      */
     BasicQosOKFrame(uint16_t channel) : BasicFrame(channel, 0) {}
-    
+
     /**
      *  Constructor based on incoming data
      *  @param  frame
@@ -52,7 +52,7 @@ public:
     {
         return 11;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -62,13 +62,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
+        if (!channel) return false;
+
         // report
-        channel->reportQosSet();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/basicrecoverokframe.h b/src/basicrecoverokframe.h
index 66004b1..1bcd771 100644
--- a/src/basicrecoverokframe.h
+++ b/src/basicrecoverokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a basic recover-async frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -57,7 +57,7 @@ public:
     {
         return 111;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -67,17 +67,17 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
+        if (!channel) return false;
+
         // report
-        channel->reportRecovering();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
-    
+
 
 };
 
diff --git a/src/channelflowokframe.h b/src/channelflowokframe.h
index efc3ae6..fcd325f 100644
--- a/src/channelflowokframe.h
+++ b/src/channelflowokframe.h
@@ -88,14 +88,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
-        // is the flow active?
-        if (active()) channel->reportResumed();
-        else channel->reportPaused();
-        
+        if (!channel) return false;
+
+        // report success for the call
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 28a3f09..c951f5e 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -55,13 +55,13 @@ ChannelImpl::ChannelImpl(Channel *parent, Connection *connection, ChannelHandler
 {
     // add the channel to the connection
     _id = _connection->add(this);
-    
+
     // check if the id is valid
     if (_id == 0)
     {
         // this is invalid
         _state = state_closed;
-        
+
         // invalid id, this channel can not exist
         handler->onError(_parent, "Max number of channels reached");
     }
@@ -69,7 +69,7 @@ ChannelImpl::ChannelImpl(Channel *parent, Connection *connection, ChannelHandler
     {
         // busy connecting
         _state = state_connected;
-        
+
         // valid id, send a channel open frame
         send(ChannelOpenFrame(_id));
     }
@@ -80,106 +80,114 @@ ChannelImpl::ChannelImpl(Channel *parent, Connection *connection, ChannelHandler
  */
 ChannelImpl::~ChannelImpl()
 {
-    // remove incoming message 
+    // remove incoming message
     if (_message) delete _message;
     _message = nullptr;
-    
+
     // remove this channel from the connection (but not if the connection is already destructed)
     if (_connection) _connection->remove(this);
-    
+
     // close the channel now
     close();
 }
 
 /**
  *  Pause deliveries on a channel
- * 
+ *
  *  This will stop all incoming messages
- *  
- *  This method returns true if the request to pause has been sent to the
- *  broker. This does not necessarily mean that the channel is already
- *  paused. 
- * 
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::pause()
+Deferred<>& ChannelImpl::pause()
 {
-    // send a flow frame
-    return send(ChannelFlowFrame(_id, false));
+    // send a channel flow frame
+    return send(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
 }
 
 /**
  *  Resume a paused channel
- * 
- *  @return bool
+ *
+ *  This will resume incoming messages
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::resume()
+Deferred<>& ChannelImpl::resume()
 {
-    // send a flow frame
-    return send(ChannelFlowFrame(_id, true));
+    // send a channel flow frame
+    return send(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
 }
 
 /**
  *  Start a transaction
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::startTransaction()
+Deferred<>& ChannelImpl::startTransaction()
 {
-    // send a flow frame
-    return send(TransactionSelectFrame(_id));
-}    
+    // send a transaction frame
+    return send(TransactionSelectFrame(_id), "Cannot send transaction start frame");
+}
 
 /**
  *  Commit the current transaction
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::commitTransaction()
+Deferred<>& ChannelImpl::commitTransaction()
 {
-    // send a flow frame
-    return send(TransactionCommitFrame(_id));
+    // send a transaction frame
+    return send(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
  *  Rollback the current transaction
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::rollbackTransaction()
+Deferred<>& ChannelImpl::rollbackTransaction()
 {
-    // send a flow frame
-    return send(TransactionRollbackFrame(_id));
+    // send a transaction frame
+    return send(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
  *  Close the current channel
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::close()
+Deferred<>& ChannelImpl::close()
 {
     // channel could be dead after send operation, we need to monitor that
     Monitor monitor(this);
 
-    // send a flow frame
-    if (!send(ChannelCloseFrame(_id))) return false;
+    // send a channel close frame
+    auto &handler = send(ChannelCloseFrame(_id), "Cannot send channel close frame");
 
-    // leap out if channel was destructed
-    if (!monitor.valid()) return true;
-
-    // now it is closing
-    _state = state_closing;
+    // was the frame sent and are we still alive?
+    if (handler && monitor.valid()) _state = state_closing;
 
     // done
-    return true;
+    return handler;
 }
 
 /**
  *  declare an exchange
+
  *  @param  name        name of the exchange to declare
  *  @param  type        type of exchange
  *  @param  flags       additional settings for the exchange
  *  @param  arguments   additional arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments)
+Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments)
 {
     // convert exchange type
     std::string exchangeType;
@@ -189,49 +197,58 @@ bool ChannelImpl::declareExchange(const std::string &name, ExchangeType type, in
     if (type == ExchangeType::headers)exchangeType = "headers";
 
     // send declare exchange frame
-    return send(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments));
+    return send(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
 }
 
 /**
  *  bind an exchange
+ *
  *  @param  source      exchange which binds to target
  *  @param  target      exchange to bind to
  *  @param  routingKey  routing key
  *  @param  flags       additional flags
  *  @param  arguments   additional arguments for binding
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred<>& ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange bind frame
-    return send(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments));
+    return send(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
 }
 
 /**
  *  unbind two exchanges
+ *
  *  @param  source      the source exchange
  *  @param  target      the target exchange
  *  @param  routingkey  the routing key
  *  @param  flags       optional flags
  *  @param  arguments   additional unbind arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred<>& ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange unbind frame
-    return send(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments));
+    return send(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
 }
 
 /**
  *  remove an exchange
+ *
  *  @param  name        name of the exchange to remove
  *  @param  flags       additional settings for deleting the exchange
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::removeExchange(const std::string &name, int flags)
+Deferred<>& ChannelImpl::removeExchange(const std::string &name, int flags)
 {
     // send delete exchange frame
-    return send(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait));
+    return send(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
 }
 
 /**
@@ -239,75 +256,107 @@ bool ChannelImpl::removeExchange(const std::string &name, int flags)
  *  @param  name        queue name
  *  @param  flags       additional settings for the queue
  *  @param  arguments   additional arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
+Deferred<const std::string&, uint32_t, uint32_t>& ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
 {
     // send the queuedeclareframe
-    return send(QueueDeclareFrame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments));
+    return send(QueueDeclareFrame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments), "Cannot send queue declare frame", _queueDeclaredCallbacks);
 }
 
 /**
  *  Bind a queue to an exchange
+ *
  *  @param  exchangeName    name of the exchange to bind to
  *  @param  queueName       name of the queue
  *  @param  routingkey      routingkey
  *  @param  flags           additional flags
  *  @param  arguments       additional arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
+Deferred<>& ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send the bind queue frame
-    return send(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments));
+    return send(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
 }
 
 /**
  *  Unbind a queue from an exchange
+ *
  *  @param  exchange    the source exchange
  *  @param  queue       the target queue
  *  @param  routingkey  the routing key
  *  @param  arguments   additional bind arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
+Deferred<>& ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
 {
     // send the unbind queue frame
-    return send(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments));
+    return send(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
 }
 
 /**
  *  Purge a queue
  *  @param  queue       queue to purge
  *  @param  flags       additional flags
- *  @return bool    
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
+ *
+ *  The onSuccess() callback that you can install should have the following signature:
+ *
+ *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+ *
+ *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+ *
+ *      std::cout << "Queue purged, all " << messageCount << " messages removed" << std::endl;
+ *
+ *  });
  */
-bool ChannelImpl::purgeQueue(const std::string &name, int flags)
+Deferred<uint32_t>& ChannelImpl::purgeQueue(const std::string &name, int flags)
 {
     // send the queue purge frame
-    return send(QueuePurgeFrame(_id, name, flags & nowait));
+    return send(QueuePurgeFrame(_id, name, flags & nowait), "Cannot send queue purge frame", _queueRemovedCallbacks);
 }
 
 /**
  *  Remove a queue
  *  @param  queue       queue to remove
  *  @param  flags       additional flags
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
+ *
+ *  The onSuccess() callback that you can install should have the following signature:
+ *
+ *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
+ *
+ *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+ *
+ *      std::cout << "Queue deleted, along with " << messageCount << " messages" << std::endl;
+ *
+ *  });
  */
-bool ChannelImpl::removeQueue(const std::string &name, int flags)
+Deferred<uint32_t>& ChannelImpl::removeQueue(const std::string &name, int flags)
 {
     // send the remove queue frame
-    return send(QueueDeleteFrame(_id, name, flags & ifunused, flags & ifempty, flags & nowait));
+    return send(QueueDeleteFrame(_id, name, flags & ifunused, flags & ifempty, flags & nowait), "Cannot send remove queue frame", _queueRemovedCallbacks);
 }
 
 /**
  *  Publish a message to an exchange
- * 
+ *
  *  The following flags can be used
- * 
+ *
  *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
  *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
- * 
+ *
  *  @param  exchange    the exchange to publish to
  *  @param  routingkey  the routing key
  *  @param  flags       optional flags (see above)
@@ -320,46 +369,46 @@ bool ChannelImpl::publish(const std::string &exchange, const std::string &routin
     // we are going to send out multiple frames, each one will trigger a call to the handler,
     // which in turn could destruct the channel object, we need to monitor that
     Monitor monitor(this);
-    
+
     // @todo do not copy the entire buffer to individual frames
-    
+
     // send the publish frame
     if (!send(BasicPublishFrame(_id, exchange, routingKey, flags & mandatory, flags & immediate))) return false;
-    
+
     // channel still valid?
     if (!monitor.valid()) return false;
 
     // send header
     if (!send(BasicHeaderFrame(_id, envelope))) return false;
-    
+
     // channel and connection still valid?
     if (!monitor.valid() || !_connection) return false;
-    
+
     // the max payload size is the max frame size minus the bytes for headers and trailer
     uint32_t maxpayload = _connection->maxPayload();
     uint32_t bytessent = 0;
-    
+
     // the buffer
     const char *data = envelope.body();
     uint32_t bytesleft = envelope.bodySize();
-    
+
     // split up the body in multiple frames depending on the max frame size
     while (bytesleft > 0)
     {
         // size of this chunk
         uint32_t chunksize = std::min(maxpayload, bytesleft);
-        
+
         // send out a body frame
         if (!send(BodyFrame(_id, data + bytessent, chunksize))) return false;
-        
+
         // channel still valid?
         if (!monitor.valid()) return false;
-        
+
         // update counters
         bytessent += chunksize;
         bytesleft -= chunksize;
     }
-    
+
     // done
     return true;
 }
@@ -367,12 +416,14 @@ bool ChannelImpl::publish(const std::string &exchange, const std::string &routin
 /**
  *  Set the Quality of Service (QOS) for this channel
  *  @param  prefetchCount       maximum number of messages to prefetch
- *  @return bool                whether the Qos frame is sent.
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::setQos(uint16_t prefetchCount)
+Deferred<>& ChannelImpl::setQos(uint16_t prefetchCount)
 {
     // send a qos frame
-    return send(BasicQosFrame(_id, prefetchCount, false));
+    return send(BasicQosFrame(_id, prefetchCount, false), "Cannot send basic QOS frame");
 }
 
 /**
@@ -427,12 +478,14 @@ bool ChannelImpl::reject(uint64_t deliveryTag, int flags)
 /**
  *  Recover un-acked messages
  *  @param  flags               optional flags
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
  */
-bool ChannelImpl::recover(int flags)
+Deferred<>& ChannelImpl::recover(int flags)
 {
     // send a nack frame
-    return send(BasicRecoverFrame(_id, flags & requeue));
+    return send(BasicRecoverFrame(_id, flags & requeue), "Cannot send basic recover frame");
 }
 
 /**
@@ -444,11 +497,58 @@ bool ChannelImpl::send(const Frame &frame)
 {
     // skip if channel is not connected
     if (_state != state_connected || !_connection) return false;
-    
+
     // send to tcp connection
     return _connection->send(frame);
 }
 
+/**
+ *  Send a frame over the channel and
+ *  get a deferred handler for it.
+ *
+ *  @param  frame       frame to send
+ *  @param  message     the message to trigger if the frame cannot be send at all
+ */
+Deferred<>& ChannelImpl::send(const Frame &frame, const char *message)
+{
+    // use the generic implementation
+    return send<>(frame, message, _callbacks);
+}
+
+/**
+ *  Send a frame over the channel and
+ *  get a deferred handler for it.
+ *
+ *  @param  frame       frame to send
+ *  @param  message     the message to trigger if the frame cannot be send at all
+ *  @param  queue       the queue to store the callbacks in
+ */
+template <typename... Arguments>
+Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *message, std::deque<Deferred<Arguments...>>& queue)
+{
+    // create a new deferred handler and get a pointer to it
+    queue.push_back(Deferred<Arguments...>(_parent));
+    auto *handler = &queue.back();
+
+    // send the frame over the channel
+    if (!send(frame))
+    {
+        // we can immediately put the handler in failed state
+        handler->_failed = true;
+
+        // the frame could not be send
+        // we should register an error
+        // on the handler, but only after
+        // a timeout, so a handler can
+        // be attached first
+
+        // TODO
+    }
+
+    // return the new handler
+    return *handler;
+}
+
 /**
  *  Report the received message
  */
@@ -456,18 +556,18 @@ void ChannelImpl::reportMessage()
 {
     // skip if there is no message
     if (!_message) return;
-    
+
     // after the report the channel may be destructed, monitor that
     Monitor monitor(this);
-    
+
     // do we have a handler?
     if (_handler) _message->report(_parent, _handler);
-    
+
     // skip if channel was destructed
     if (!monitor.valid()) return;
-    
+
     // no longer need the message
-    delete _message; 
+    delete _message;
     _message = nullptr;
 }
 
@@ -480,7 +580,7 @@ MessageImpl *ChannelImpl::message(const BasicDeliverFrame &frame)
 {
     // it should not be possible that a message already exists, but lets check it anyhow
     if (_message) delete _message;
-    
+
     // construct a message
     return _message = new ConsumedMessage(frame);
 }
@@ -494,7 +594,7 @@ MessageImpl *ChannelImpl::message(const BasicReturnFrame &frame)
 {
     // it should not be possible that a message already exists, but lets check it anyhow
     if (_message) delete _message;
-    
+
     // construct a message
     return _message = new ReturnedMessage(frame);
 }
diff --git a/src/exchangebindokframe.h b/src/exchangebindokframe.h
index ad3c54c..5b1f29c 100644
--- a/src/exchangebindokframe.h
+++ b/src/exchangebindokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Exchangebindokframe.h
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -8,7 +8,7 @@
  *  Set up namespace
  */
 namespace AMQP {
-    
+
 /**
  *  Class definition
  */
@@ -29,10 +29,10 @@ protected:
 public:
     /**
      *  Constructor based on incoming data
-     * 
+     *
      *  @param  frame   received frame to decode
      */
-    ExchangeBindOKFrame(ReceivedFrame &frame) : 
+    ExchangeBindOKFrame(ReceivedFrame &frame) :
         ExchangeFrame(frame)
     {}
 
@@ -47,12 +47,12 @@ public:
     ExchangeBindOKFrame(uint16_t channel) :
         ExchangeFrame(channel, 0)
     {}
-    
+
     virtual uint16_t methodID() const override
     {
         return 31;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -62,17 +62,17 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
 
         // report to handler
-        channel->reportExchangeBound();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
 };
-    
+
 // end namespace
 }
diff --git a/src/exchangedeclareokframe.h b/src/exchangedeclareokframe.h
index b271601..f86bf3e 100644
--- a/src/exchangedeclareokframe.h
+++ b/src/exchangedeclareokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP exchange declare ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -55,7 +55,7 @@ public:
     {
         return 11;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -65,13 +65,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
-        
+
         // report exchange declare ok
-        channel->reportExchangeDeclared();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/exchangedeleteokframe.h b/src/exchangedeleteokframe.h
index c386358..ce44336 100644
--- a/src/exchangedeleteokframe.h
+++ b/src/exchangedeleteokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP exchange delete ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -32,7 +32,7 @@ public:
      *
      *  @param  frame   received frame
      */
-    ExchangeDeleteOKFrame(ReceivedFrame &frame) : 
+    ExchangeDeleteOKFrame(ReceivedFrame &frame) :
         ExchangeFrame(frame)
     {}
 
@@ -56,7 +56,7 @@ public:
     {
         return 21;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -66,13 +66,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
-        
+
         // report to handler
-        channel->reportExchangeDeleted();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/exchangeunbindokframe.h b/src/exchangeunbindokframe.h
index f3a2a9b..ea256ab 100644
--- a/src/exchangeunbindokframe.h
+++ b/src/exchangeunbindokframe.h
@@ -1,5 +1,5 @@
 /**
- *  Exchangeunbindokframe.h  
+ *  Exchangeunbindokframe.h
  *
  *  @copyright 2014 Copernica BV
  */
@@ -9,7 +9,7 @@
  *  Set up namespace
  */
 namespace AMQP {
-    
+
 /**
  *  Class definition
  */
@@ -30,10 +30,10 @@ protected:
 public:
     /**
      *  Constructor based on incoming data
-     * 
+     *
      *  @param  frame   received frame to decode
      */
-    ExchangeUnbindOKFrame(ReceivedFrame &frame) : 
+    ExchangeUnbindOKFrame(ReceivedFrame &frame) :
         ExchangeFrame(frame)
     {}
 
@@ -48,12 +48,12 @@ public:
     ExchangeUnbindOKFrame(uint16_t channel) :
         ExchangeFrame(channel, 0)
     {}
-    
+
     virtual uint16_t methodID() const override
     {
         return 51;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -63,17 +63,17 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
 
         // report to handler
-        channel->reportExchangeUnbound();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
 };
-    
+
 // end namespace
 }
diff --git a/src/methodframe.h b/src/methodframe.h
index 749e088..8b847fd 100644
--- a/src/methodframe.h
+++ b/src/methodframe.h
@@ -75,13 +75,10 @@ public:
      *  @param  connection      The connection over which it was received
      *  @return bool            Was it succesfully processed?
      */
-    virtual bool process(ConnectionImpl *connection) override
+    virtual bool process[[ noreturn ]](ConnectionImpl *connection) override
     {
         // this is an exception
         throw ProtocolException("unimplemented frame type " + std::to_string(type()) + " class " + std::to_string(classID()) + " method " + std::to_string(methodID()));
-        
-        // unreachable
-        return false;
     }
 };
 
diff --git a/src/queuebindokframe.h b/src/queuebindokframe.h
index 6c66cb2..1d55a33 100644
--- a/src/queuebindokframe.h
+++ b/src/queuebindokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue bind ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -54,7 +54,7 @@ public:
     {
         return 21;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -64,13 +64,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
-        
+
         // report to handler
-        channel->reportQueueBound();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/queueunbindokframe.h b/src/queueunbindokframe.h
index cd779f0..14a2761 100644
--- a/src/queueunbindokframe.h
+++ b/src/queueunbindokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue unbind ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -24,7 +24,7 @@ protected:
     {
         // call base
         QueueFrame::fill(buffer);
-    }    
+    }
 public:
     /**
      * Decode a queueunbindokframe from a received frame
@@ -58,7 +58,7 @@ public:
     {
         return 51;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -68,13 +68,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
-        
+
         // report queue unbind success
-        channel->reportQueueUnbound();
-        
+        channel->reportSuccess();
+
         // done
         return true;
     }
diff --git a/src/transactioncommitokframe.h b/src/transactioncommitokframe.h
index a10e1fe..27f7004 100644
--- a/src/transactioncommitokframe.h
+++ b/src/transactioncommitokframe.h
@@ -59,6 +59,26 @@ public:
     {
         return 21;
     }
+
+    /**
+     *  Process the frame
+     *  @param  connection      The connection over which it was received
+     *  @return bool            Was it succesfully processed?
+     */
+    virtual bool process(ConnectionImpl *connection) override
+    {
+        // we need the appropriate channel
+        ChannelImpl *channel = connection->channel(this->channel());
+
+        // channel does not exist
+        if(!channel) return false;
+
+        // report that the channel is open
+        channel->reportSuccess();
+
+        // done
+        return true;
+    }
 };
 
 /**
diff --git a/src/transactionrollbackokframe.h b/src/transactionrollbackokframe.h
index a203e4c..e87d893 100644
--- a/src/transactionrollbackokframe.h
+++ b/src/transactionrollbackokframe.h
@@ -58,7 +58,27 @@ public:
     virtual uint16_t methodID() const override
     {
         return 31;
-    }    
+    }
+
+    /**
+     *  Process the frame
+     *  @param  connection      The connection over which it was received
+     *  @return bool            Was it succesfully processed?
+     */
+    virtual bool process(ConnectionImpl *connection) override
+    {
+        // we need the appropriate channel
+        ChannelImpl *channel = connection->channel(this->channel());
+
+        // channel does not exist
+        if(!channel) return false;
+
+        // report that the channel is open
+        channel->reportSuccess();
+
+        // done
+        return true;
+    }
 };
 
 /**
diff --git a/src/transactionselectokframe.h b/src/transactionselectokframe.h
index 9529144..8a842f7 100644
--- a/src/transactionselectokframe.h
+++ b/src/transactionselectokframe.h
@@ -59,6 +59,26 @@ public:
     {
         return 11;
     }
+
+    /**
+     *  Process the frame
+     *  @param  connection      The connection over which it was received
+     *  @return bool            Was it succesfully processed?
+     */
+    virtual bool process(ConnectionImpl *connection) override
+    {
+        // we need the appropriate channel
+        ChannelImpl *channel = connection->channel(this->channel());
+
+        // channel does not exist
+        if(!channel) return false;
+
+        // report that the channel is open
+        channel->reportSuccess();
+
+        // done
+        return true;
+    }
 };
 
 /**

From e1b0e3dea1909142ed817c7c2fd68a6451672e9a Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Tue, 8 Apr 2014 16:12:04 +0200
Subject: [PATCH 07/41] Added a generic callback class that acts as a container
 for the different types of callbacks

---
 amqpcpp.h                 |  1 +
 include/callbacks.h       | 10 ++---
 include/channelimpl.h     | 83 +++++++--------------------------------
 include/deferred.h        |  2 +
 src/channelimpl.cpp       | 56 ++++++++++----------------
 src/queuedeclareokframe.h | 22 +++++------
 src/queuedeleteokframe.h  | 14 +++----
 src/queuepurgeokframe.h   | 12 +++---
 8 files changed, 67 insertions(+), 133 deletions(-)

diff --git a/amqpcpp.h b/amqpcpp.h
index af79811..430844c 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -17,6 +17,7 @@
 #include <cstddef>
 #include <cstring>
 #include <stdexcept>
+#include <utility>
 
 // base C include files
 #include <stdint.h>
diff --git a/include/callbacks.h b/include/callbacks.h
index b29bb38..3ed7601 100644
--- a/include/callbacks.h
+++ b/include/callbacks.h
@@ -90,13 +90,13 @@ public:
      *  @return reference to the inserted deferred
      */
     template <typename... Arguments>
-    Deferred<Arguments...>& push_back(const Deferred<Arguments...>& item)
+    Deferred<Arguments...>& push_back(Deferred<Arguments...>&& item)
     {
         // retrieve the container
         auto &container = get<std::deque<Deferred<Arguments...>>>(_callbacks);
 
         // add the element
-        container.push_back(item);
+        container.push_back(std::move(item));
 
         // return reference to the new item
         return container.back();
@@ -128,7 +128,7 @@ public:
      */
     template <std::size_t N = 0>
     typename std::enable_if<N == std::tuple_size<decltype(_callbacks)>::value>::type
-    reportFailure(const std::string& message)
+    reportError(const std::string& message)
     {}
 
     /**
@@ -138,7 +138,7 @@ public:
      */
     template <std::size_t N = 0>
     typename std::enable_if<N < std::tuple_size<decltype(_callbacks)>::value>::type
-    reportFailure(const std::string& message)
+    reportError(const std::string& message)
     {
         // retrieve the callbacks at current index
         auto &callbacks = std::get<N>(_callbacks);
@@ -147,7 +147,7 @@ public:
         for (auto &callback : callbacks) callback.error(message);
 
         // execute the next type
-        reportFailure<N + 1>(message);
+        reportError<N + 1>(message);
     }
 };
 
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 6651e9b..cf75dfb 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -51,13 +51,7 @@ private:
     /**
      *  The callbacks waiting to be called
      */
-    std::deque<Deferred<>> _callbacks;
-
-    /**
-     *  Callbacks with additional parameters
-     */
-    std::deque<Deferred<const std::string&, uint32_t, uint32_t>> _queueDeclaredCallbacks;
-    std::deque<Deferred<uint32_t>> _queueRemovedCallbacks;
+    Callbacks _callbacks;
 
     /**
      *  The channel number
@@ -399,18 +393,17 @@ public:
      *  @param  frame       frame to send
      *  @param  message     the message to trigger if the frame cannot be send at all
      */
-    Deferred<>& send(const Frame &frame, const char *message);
+    template <typename... Arguments>
+    Deferred<Arguments...>& send(const Frame &frame, const char *message);
 
     /**
-     *  Send a frame over the channel and
-     *  get a deferred handler for it.
-     *
-     *  @param  frame       frame to send
-     *  @param  message     the message to trigger if the frame cannot be send at all
-     *  @param  queue       the queue to store the callbacks in
+     *  Report to the handler that the channel is opened
      */
-    template <typename... Arguments>
-    Deferred<Arguments...>& send(const Frame &frame, const char *message, std::deque<Deferred<Arguments...>>& queue);
+    void reportReady()
+    {
+        // inform handler
+        if (_readyCallback) _readyCallback(_parent);
+    }
 
     /**
      *  Report to the handler that the channel is closed
@@ -430,20 +423,11 @@ public:
      *  This function is called to report success for all
      *  cases where the callback does not receive any parameters
      */
-    void reportSuccess()
+    template <typename... Arguments>
+    void reportSuccess(Arguments ...parameters)
     {
-        // report success for the oldest request
-        _callbacks.front().success();
-        _callbacks.pop_front();
-    }
-
-    /**
-     *  Report to the handler that the channel is opened
-     */
-    void reportReady()
-    {
-        // inform handler
-        if (_readyCallback) _readyCallback(_parent);
+        // report success to the relevant callback
+        _callbacks.reportSuccess<Arguments...>(std::forward<Arguments>(parameters)...);
     }
 
     /**
@@ -458,45 +442,8 @@ public:
         // inform handler
         if (_errorCallback) _errorCallback(_parent, message);
 
-        // and all waiting deferred callbacks
-        for (auto &deferred : _callbacks)               deferred.error(message);
-        for (auto &deferred : _queueDeclaredCallbacks)  deferred.error(message);
-        for (auto &deferred : _queueRemovedCallbacks)   deferred.error(message);
-    }
-
-    /**
-     *  Report that the queue was succesfully declared
-     *  @param  queueName       name of the queue which was declared
-     *  @param  messagecount    number of messages currently in the queue
-     *  @param  consumerCount   number of active consumers in the queue
-     */
-    void reportQueueDeclared(const std::string &queueName, uint32_t messageCount, uint32_t consumerCount)
-    {
-        // report success for the oldest queue declare callbacks
-        _queueDeclaredCallbacks.front().success(queueName, messageCount, consumerCount);
-        _queueDeclaredCallbacks.pop_front();
-    }
-
-    /**
-     *  Report that a queue was succesfully deleted
-     *  @param  messageCount    number of messages left in queue, now deleted
-     */
-    void reportQueueDeleted(uint32_t messageCount)
-    {
-        // report success for the oldest queue remove callbacks
-        _queueRemovedCallbacks.front().success(messageCount);
-        _queueRemovedCallbacks.pop_front();
-    }
-
-    /**
-     *  Report that a queue was succesfully purged
-     *  @param  messageCount    number of messages purged
-     */
-    void reportQueuePurged(uint32_t messageCount)
-    {
-        // report success for the oldest queue remove callbacks
-        _queueRemovedCallbacks.front().success(messageCount);
-        _queueRemovedCallbacks.pop_front();
+        // report to all waiting callbacks too
+        _callbacks.reportError(message);
     }
 
     /**
diff --git a/include/deferred.h b/include/deferred.h
index 8e0e9a0..2d99187 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -15,6 +15,7 @@ namespace AMQP {
 
 // forward declaration
 class ChannelImpl;
+class Callbacks;
 
 /**
  *  Class definition
@@ -53,6 +54,7 @@ private:
      *  private members and construct us
      */
     friend class ChannelImpl;
+    friend class Callbacks;
 
     /**
      *  Indicate success
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index c951f5e..10ea529 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -102,7 +102,7 @@ ChannelImpl::~ChannelImpl()
 Deferred<>& ChannelImpl::pause()
 {
     // send a channel flow frame
-    return send(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
+    return send<>(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
 }
 
 /**
@@ -116,7 +116,7 @@ Deferred<>& ChannelImpl::pause()
 Deferred<>& ChannelImpl::resume()
 {
     // send a channel flow frame
-    return send(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
+    return send<>(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
 }
 
 /**
@@ -128,7 +128,7 @@ Deferred<>& ChannelImpl::resume()
 Deferred<>& ChannelImpl::startTransaction()
 {
     // send a transaction frame
-    return send(TransactionSelectFrame(_id), "Cannot send transaction start frame");
+    return send<>(TransactionSelectFrame(_id), "Cannot send transaction start frame");
 }
 
 /**
@@ -140,7 +140,7 @@ Deferred<>& ChannelImpl::startTransaction()
 Deferred<>& ChannelImpl::commitTransaction()
 {
     // send a transaction frame
-    return send(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
+    return send<>(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
@@ -152,7 +152,7 @@ Deferred<>& ChannelImpl::commitTransaction()
 Deferred<>& ChannelImpl::rollbackTransaction()
 {
     // send a transaction frame
-    return send(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
+    return send<>(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
@@ -167,7 +167,7 @@ Deferred<>& ChannelImpl::close()
     Monitor monitor(this);
 
     // send a channel close frame
-    auto &handler = send(ChannelCloseFrame(_id), "Cannot send channel close frame");
+    auto &handler = send<>(ChannelCloseFrame(_id), "Cannot send channel close frame");
 
     // was the frame sent and are we still alive?
     if (handler && monitor.valid()) _state = state_closing;
@@ -197,7 +197,7 @@ Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType t
     if (type == ExchangeType::headers)exchangeType = "headers";
 
     // send declare exchange frame
-    return send(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
+    return send<>(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
 }
 
 /**
@@ -215,7 +215,7 @@ Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType t
 Deferred<>& ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange bind frame
-    return send(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
+    return send<>(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
 }
 
 /**
@@ -233,7 +233,7 @@ Deferred<>& ChannelImpl::bindExchange(const std::string &source, const std::stri
 Deferred<>& ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange unbind frame
-    return send(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
+    return send<>(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
 }
 
 /**
@@ -248,7 +248,7 @@ Deferred<>& ChannelImpl::unbindExchange(const std::string &source, const std::st
 Deferred<>& ChannelImpl::removeExchange(const std::string &name, int flags)
 {
     // send delete exchange frame
-    return send(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
+    return send<>(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
 }
 
 /**
@@ -263,7 +263,7 @@ Deferred<>& ChannelImpl::removeExchange(const std::string &name, int flags)
 Deferred<const std::string&, uint32_t, uint32_t>& ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
 {
     // send the queuedeclareframe
-    return send(QueueDeclareFrame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments), "Cannot send queue declare frame", _queueDeclaredCallbacks);
+    return send<const std::string&, uint32_t, uint32_t>(QueueDeclareFrame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments), "Cannot send queue declare frame");
 }
 
 /**
@@ -281,7 +281,7 @@ Deferred<const std::string&, uint32_t, uint32_t>& ChannelImpl::declareQueue(cons
 Deferred<>& ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send the bind queue frame
-    return send(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
+    return send<>(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
 }
 
 /**
@@ -298,7 +298,7 @@ Deferred<>& ChannelImpl::bindQueue(const std::string &exchangeName, const std::s
 Deferred<>& ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
 {
     // send the unbind queue frame
-    return send(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
+    return send<>(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
 }
 
 /**
@@ -322,7 +322,7 @@ Deferred<>& ChannelImpl::unbindQueue(const std::string &exchange, const std::str
 Deferred<uint32_t>& ChannelImpl::purgeQueue(const std::string &name, int flags)
 {
     // send the queue purge frame
-    return send(QueuePurgeFrame(_id, name, flags & nowait), "Cannot send queue purge frame", _queueRemovedCallbacks);
+    return send<uint32_t>(QueuePurgeFrame(_id, name, flags & nowait), "Cannot send queue purge frame");
 }
 
 /**
@@ -346,7 +346,7 @@ Deferred<uint32_t>& ChannelImpl::purgeQueue(const std::string &name, int flags)
 Deferred<uint32_t>& ChannelImpl::removeQueue(const std::string &name, int flags)
 {
     // send the remove queue frame
-    return send(QueueDeleteFrame(_id, name, flags & ifunused, flags & ifempty, flags & nowait), "Cannot send remove queue frame", _queueRemovedCallbacks);
+    return send<uint32_t>(QueueDeleteFrame(_id, name, flags & ifunused, flags & ifempty, flags & nowait), "Cannot send remove queue frame");
 }
 
 /**
@@ -503,38 +503,22 @@ bool ChannelImpl::send(const Frame &frame)
 }
 
 /**
- *  Send a frame over the channel and
- *  get a deferred handler for it.
+ *  Send a frame over the channel and get a deferred handler for it.
  *
  *  @param  frame       frame to send
  *  @param  message     the message to trigger if the frame cannot be send at all
  */
-Deferred<>& ChannelImpl::send(const Frame &frame, const char *message)
-{
-    // use the generic implementation
-    return send<>(frame, message, _callbacks);
-}
-
-/**
- *  Send a frame over the channel and
- *  get a deferred handler for it.
- *
- *  @param  frame       frame to send
- *  @param  message     the message to trigger if the frame cannot be send at all
- *  @param  queue       the queue to store the callbacks in
- */
 template <typename... Arguments>
-Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *message, std::deque<Deferred<Arguments...>>& queue)
+Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *message)
 {
     // create a new deferred handler and get a pointer to it
-    queue.push_back(Deferred<Arguments...>(_parent));
-    auto *handler = &queue.back();
+    auto &handler = _callbacks.push_back(Deferred<Arguments...>(_parent));
 
     // send the frame over the channel
     if (!send(frame))
     {
         // we can immediately put the handler in failed state
-        handler->_failed = true;
+        handler._failed = true;
 
         // the frame could not be send
         // we should register an error
@@ -546,7 +530,7 @@ Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *messag
     }
 
     // return the new handler
-    return *handler;
+    return handler;
 }
 
 /**
diff --git a/src/queuedeclareokframe.h b/src/queuedeclareokframe.h
index 3cbc113..875ff2b 100644
--- a/src/queuedeclareokframe.h
+++ b/src/queuedeclareokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue declare ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -70,7 +70,7 @@ public:
 
     /**
      *  Constructor based on incoming data
-     *  @param  frame   received frame 
+     *  @param  frame   received frame
      */
     QueueDeclareOKFrame(ReceivedFrame &frame) :
         QueueFrame(frame),
@@ -91,7 +91,7 @@ public:
     {
         return 11;
     }
-    
+
     /**
      *  Queue name
      *  @return string
@@ -105,7 +105,7 @@ public:
      *  Number of messages
      *  @return int32_t
      */
-    int32_t messageCount() const
+    uint32_t messageCount() const
     {
         return _messageCount;
     }
@@ -114,11 +114,11 @@ public:
      *  Number of consumers
      *  @return int32_t
      */
-    int32_t consumerCount() const
+    uint32_t consumerCount() const
     {
         return _consumerCount;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -128,13 +128,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // what if channel doesn't exist?
         if (!channel) return false;
-        
-        // report to the handler
-        channel->reportQueueDeclared(this->name(), this->messageCount(), this->consumerCount());
-        
+
+        // report to the handler, we need to specify template arguments otherwise a string will lose const and reference
+        channel->reportSuccess<const std::string&, uint32_t, uint32_t>(this->name(), this->messageCount(), this->consumerCount());
+
         // done
         return true;
     }
diff --git a/src/queuedeleteokframe.h b/src/queuedeleteokframe.h
index 881ed2b..39cd9b5 100644
--- a/src/queuedeleteokframe.h
+++ b/src/queuedeleteokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue delete frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -79,7 +79,7 @@ public:
     {
         return _messageCount;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -89,13 +89,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
-        
+
         // report queue deletion success
-        channel->reportQueueDeleted(this->messageCount());
-        
+        channel->reportSuccess(this->messageCount());
+
         // done
         return true;
     }
@@ -105,4 +105,4 @@ public:
  *  end namespace
  */
 }
- 
+
diff --git a/src/queuepurgeokframe.h b/src/queuepurgeokframe.h
index 715ef00..166cb60 100644
--- a/src/queuepurgeokframe.h
+++ b/src/queuepurgeokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue purge frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -35,7 +35,7 @@ protected:
         // add fields
         buffer.add(_messageCount);
     }
-    
+
 public:
     /**
      *  Construct a queuepurgeokframe
@@ -79,7 +79,7 @@ public:
     {
         return _messageCount;
     }
-    
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
@@ -89,13 +89,13 @@ public:
     {
         // check if we have a channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
         if(!channel) return false;
 
         // report queue purge success
-        channel->reportQueuePurged(this->messageCount());
-        
+        channel->reportSuccess(this->messageCount());
+
         // done
         return true;
     }

From d2c17869e0b644ac9e9955aeff72c39bca3de19d Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Thu, 10 Apr 2014 12:51:04 +0200
Subject: [PATCH 08/41] Moved the remaining methods over to deferred handlers

---
 amqpcpp.h                 |   2 +-
 include/callbacks.h       |   3 +-
 include/channel.h         |  82 ++++---
 include/channelhandler.h  |  87 --------
 include/channelimpl.h     |  97 +++++----
 include/deferred.h        |  38 ++--
 src/basiccancelokframe.h  |  14 +-
 src/basicconsumeokframe.h |  12 +-
 src/basicreturnframe.h    |  13 +-
 src/channelimpl.cpp       | 105 +++++----
 src/consumedmessage.h     |  19 +-
 src/messageimpl.h         |  29 ++-
 src/returnedmessage.h     |  14 +-
 tests/main.cpp            |   4 +-
 tests/myconnection.cpp    | 448 ++++++++++++--------------------------
 tests/myconnection.h      | 195 ++---------------
 16 files changed, 388 insertions(+), 774 deletions(-)
 delete mode 100644 include/channelhandler.h

diff --git a/amqpcpp.h b/amqpcpp.h
index 430844c..908da12 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -51,8 +51,8 @@
 #include <amqpcpp/exchangetype.h>
 #include <amqpcpp/flags.h>
 #include <amqpcpp/deferred.h>
+#include <amqpcpp/deferredconsumer.h>
 #include <amqpcpp/callbacks.h>
-#include <amqpcpp/channelhandler.h>
 #include <amqpcpp/channelimpl.h>
 #include <amqpcpp/channel.h>
 #include <amqpcpp/login.h>
diff --git a/include/callbacks.h b/include/callbacks.h
index 3ed7601..9d378df 100644
--- a/include/callbacks.h
+++ b/include/callbacks.h
@@ -23,7 +23,8 @@ private:
     std::tuple<
         std::deque<Deferred<>>,
         std::deque<Deferred<const std::string&, uint32_t, uint32_t>>,
-        std::deque<Deferred<uint32_t>>
+        std::deque<Deferred<uint32_t>>,
+        std::deque<Deferred<const std::string&>>
     > _callbacks;
 
     /**
diff --git a/include/channel.h b/include/channel.h
index 8a2550a..e5df3d3 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -26,9 +26,8 @@ public:
     /**
      *  Construct a channel object
      *  @param  connection
-     *  @param  handler
      */
-    Channel(Connection *connection, ChannelHandler *handler) : _implementation(this, connection, handler) {}
+    Channel(Connection *connection) : _implementation(this, connection) {}
 
     /**
      *  Destructor
@@ -324,7 +323,7 @@ public:
      *
      *      void myCallback(AMQP::Channel *channel, uint32_t messageCount);
      *
-     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+     *  For example: channel.removeQueue("myqueue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
      *
      *      std::cout << "Queue deleted, along with " << messageCount << " messages" << std::endl;
      *
@@ -335,29 +334,20 @@ public:
     /**
      *  Publish a message to an exchange
      *
-     *  The following flags can be used
-     *
-     *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
-     *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
-     *
      *  If either of the two flags is set, and the message could not immediately
      *  be published, the message is returned by the server to the client. If you
-     *  want to catch such returned messages, you need to implement the
-     *  ChannelHandler::onReturned() method.
+     *  want to catch such returned messages, you need to install a handler using
+     *  the onReturned() method.
      *
      *  @param  exchange    the exchange to publish to
      *  @param  routingkey  the routing key
-     *  @param  flags       optional flags (see above)
      *  @param  envelope    the full envelope to send
      *  @param  message     the message to send
      *  @param  size        size of the message
      */
-    bool publish(const std::string &exchange, const std::string &routingKey, int flags, const Envelope &envelope) { return _implementation.publish(exchange, routingKey, flags, envelope); }
-    bool publish(const std::string &exchange, const std::string &routingKey, const Envelope &envelope) { return _implementation.publish(exchange, routingKey, 0, envelope); }
-    bool publish(const std::string &exchange, const std::string &routingKey, int flags, const std::string &message) { return _implementation.publish(exchange, routingKey, flags, Envelope(message)); }
-    bool publish(const std::string &exchange, const std::string &routingKey, const std::string &message) { return _implementation.publish(exchange, routingKey, 0, Envelope(message)); }
-    bool publish(const std::string &exchange, const std::string &routingKey, int flags, const char *message, size_t size) { return _implementation.publish(exchange, routingKey, flags, Envelope(message, size)); }
-    bool publish(const std::string &exchange, const std::string &routingKey, const char *message, size_t size) { return _implementation.publish(exchange, routingKey, 0, Envelope(message, size)); }
+    bool publish(const std::string &exchange, const std::string &routingKey, const Envelope &envelope) { return _implementation.publish(exchange, routingKey, envelope); }
+    bool publish(const std::string &exchange, const std::string &routingKey, const std::string &message) { return _implementation.publish(exchange, routingKey, Envelope(message)); }
+    bool publish(const std::string &exchange, const std::string &routingKey, const char *message, size_t size) { return _implementation.publish(exchange, routingKey, Envelope(message, size)); }
 
     /**
      *  Set the Quality of Service (QOS) for this channel
@@ -392,7 +382,7 @@ public:
      *      -   exclusive           request exclusive access, only this consumer can access the queue
      *      -   nowait              the server does not have to send a response back that consuming is active
      *
-     *  The method ChannelHandler::onConsumerStarted() will be called when the
+     *  The method Deferred::onSuccess() will be called when the
      *  consumer has started (unless the nowait option was set, in which case
      *  no confirmation method is called)
      *
@@ -400,14 +390,26 @@ public:
      *  @param  tag                 a consumer tag that will be associated with this consume operation
      *  @param  flags               additional flags
      *  @param  arguments           additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+     *
+     *  For example: channel.consume("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+     *
+     *      std::cout << "Started consuming under tag " << tag << std::endl;
+     *
+     *  });
      */
-    bool consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments) { return _implementation.consume(queue, tag, flags, arguments); }
-    bool consume(const std::string &queue, const std::string &tag, int flags = 0) { return _implementation.consume(queue, tag, flags, Table()); }
-    bool consume(const std::string &queue, const std::string &tag, const Table &arguments) { return _implementation.consume(queue, tag, 0, arguments); }
-    bool consume(const std::string &queue, int flags, const Table &arguments) { return _implementation.consume(queue, std::string(), flags, arguments); }
-    bool consume(const std::string &queue, int flags = 0) { return _implementation.consume(queue, std::string(), flags, Table()); }
-    bool consume(const std::string &queue, const Table &arguments) { return _implementation.consume(queue, std::string(), 0, arguments); }
+    DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments) { return _implementation.consume(queue, tag, flags, arguments); }
+    DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags = 0) { return _implementation.consume(queue, tag, flags, Table()); }
+    DeferredConsumer& consume(const std::string &queue, const std::string &tag, const Table &arguments) { return _implementation.consume(queue, tag, 0, arguments); }
+    DeferredConsumer& consume(const std::string &queue, int flags, const Table &arguments) { return _implementation.consume(queue, std::string(), flags, arguments); }
+    DeferredConsumer& consume(const std::string &queue, int flags = 0) { return _implementation.consume(queue, std::string(), flags, Table()); }
+    DeferredConsumer& consume(const std::string &queue, const Table &arguments) { return _implementation.consume(queue, std::string(), 0, arguments); }
 
     /**
      *  Cancel a running consume call
@@ -418,27 +420,39 @@ public:
      *
      *      -   nowait              the server does not have to send a response back that the consumer has been cancelled
      *
-     *  The method ChannelHandler::onConsumerStopped() will be called when the consumer
+     *  The method Deferred::onSuccess() will be called when the consumer
      *  was succesfully stopped (unless the nowait option was used, in which case no
      *  confirmation method is called)
      *
      *  @param  tag                 the consumer tag
      *  @param  flags               optional additional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+     *
+     *  For example: channel.cancel("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+     *
+     *      std::cout << "Stopped consuming under tag " << tag << std::endl;
+     *
+     *  });
      */
-    bool cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
+    Deferred<const std::string&>& cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
 
     /**
      *  Acknoldge a received message
      *
-     *  When a message is received in the ChannelHandler::onReceived() method,
-     *  you must acknoledge it so that RabbitMQ removes it from the queue (unless
+     *  When a message is received in the DeferredConsumer::onReceived() method,
+     *  you must acknowledge it so that RabbitMQ removes it from the queue (unless
      *  you are consuming with the noack option). This method can be used for
-     *  this acknoledging.
+     *  this acknowledging.
      *
      *  The following flags are supported:
      *
-     *      -   multiple            acknoledge multiple messages: all un-acked messages that were earlier delivered are acknowledged too
+     *      -   multiple            acknowledge multiple messages: all un-acked messages that were earlier delivered are acknowledged too
      *
      *  @param  deliveryTag         the unique delivery tag of the message
      *  @param  flags               optional flags
@@ -449,8 +463,8 @@ public:
     /**
      *  Reject or nack a message
      *
-     *  When a message was received in the ChannelHandler::onReceived() method,
-     *  and you don't want to acknoledge it, you can also choose to reject it by
+     *  When a message was received in the DeferredConsumer::onReceived() method,
+     *  and you don't want to acknowledge it, you can also choose to reject it by
      *  calling this reject method.
      *
      *  The following flags are supported:
diff --git a/include/channelhandler.h b/include/channelhandler.h
deleted file mode 100644
index 2ad468f..0000000
--- a/include/channelhandler.h
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-/**
- *  ChannelHandler.h
- *
- *  Interface that should be implemented by a user of the AMQP library,
- *  and that is passed to the Connection::createChannel() method.
- *
- *  This interface contains a number of methods that are called when
- *  the channel changes state.
- *
- *  @copyright 2014 Copernica BV
- */
-
-/**
- *  Set up namespace
- */
-namespace AMQP {
-
-/**
- *  Class definition
- */
-class ChannelHandler
-{
-public:
-    /**
-     *  An error has occured on the channel
-     *  The channel is no longer usable after an error has occured on it.
-     *  @param  channel         the channel on which the error occured
-     *  @param  message         human readable error message
-     */
-    virtual void onError(Channel *channel, const std::string &message) {}
-
-    /**
-     *  Method that is called when a queue is purged
-     *  This is the result of a call to Channel::purgeQueue()
-     *  @param  channel         the channel on which the queue was emptied
-     *  @param  messageCount    number of message purged
-     */
-    virtual void onQueuePurged(Channel *channel, uint32_t messageCount) {}
-
-    /**
-     *  Method that is called when a consumer was started
-     *  This is the result of a call to Channel::consume()
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  tag             the consumer tag
-     */
-    virtual void onConsumerStarted(Channel *channel, const std::string &tag) {}
-
-    /**
-     *  Method that is called when a consumer was stopped
-     *  This is the result of a call to Channel::cancel()
-     *  @param  channel         the channel on which the consumer was stopped
-     *  @param  tag             the consumer tag
-     */
-    virtual void onConsumerStopped(Channel *channel, const std::string &tag) {}
-
-    /**
-     *  Method that is called when a message has been received on a channel
-     *  This message will be called for every message that is received after
-     *  you started consuming. Make sure you acknowledge the messages when its
-     *  safe to remove them from RabbitMQ (unless you set no-ack option when you
-     *  started the consumer)
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  message         the consumed message
-     *  @param  deliveryTag     the delivery tag, you need this to acknowledge the message
-     *  @param  consumerTag     the consumer identifier that was used to retrieve this message
-     *  @param  redelivered     is this a redelivered message?
-     */
-    virtual void onReceived(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {}
-
-    /**
-     *  Method that is called when a message you tried to publish was returned
-     *  by the server. This only happens when the 'mandatory' or 'immediate' flag
-     *  was set with the Channel::publish() call.
-     *  @param  channel         the channel on which the message was returned
-     *  @param  message         the returned message
-     *  @param  code            the reply code
-     *  @param  text            human readable reply reason
-     */
-    virtual void onReturned(Channel *channel, const Message &message, int16_t code, const std::string &text) {}
-
-};
-
-/**
- *  End of namespace
- */
-}
diff --git a/include/channelimpl.h b/include/channelimpl.h
index cf75dfb..37e8e07 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -32,12 +32,6 @@ private:
      */
     ConnectionImpl *_connection;
 
-    /**
-     *  The handler that is notified about events
-     *  @var    MyChannelHandler
-     */
-    ChannelHandler *_handler;
-
     /**
      *  Callback when the channel is ready
      */
@@ -48,6 +42,11 @@ private:
      */
     std::function<void(Channel *channel, const std::string& message)> _errorCallback;
 
+    /**
+     *  Callback to execute when a message arrives
+     */
+    std::unique_ptr<DeferredConsumer> _consumer;
+
     /**
      *  The callbacks waiting to be called
      */
@@ -69,12 +68,6 @@ private:
         state_closed
     } _state = state_connected;
 
-    /**
-     *  Is a transaction now active?
-     *  @var bool
-     */
-    bool _transaction = false;
-
     /**
      *  The message that is now being received
      *  @var MessageImpl
@@ -90,9 +83,8 @@ private:
      *
      *  @param  parent          the public channel object
      *  @param  connection      pointer to the connection
-     *  @param  handler         handler that is notified on events
      */
-    ChannelImpl(Channel *parent, Connection *connection, ChannelHandler *handler = nullptr);
+    ChannelImpl(Channel *parent, Connection *connection);
 
 public:
     /**
@@ -292,23 +284,17 @@ public:
     /**
      *  Publish a message to an exchange
      *
-     *  The following flags can be used
-     *
-     *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
-     *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
-     *
      *  If the mandatory or immediate flag is set, and the message could not immediately
      *  be published, the message will be returned to the client, and will eventually
-     *  end up in your ChannelHandler::onReturned() method.
+     *  end up in your onReturned() handler method.
      *
      *  @param  exchange    the exchange to publish to
      *  @param  routingkey  the routing key
-     *  @param  flags       optional flags (see above)
      *  @param  envelope    the full envelope to send
      *  @param  message     the message to send
      *  @param  size        size of the message
      */
-    bool publish(const std::string &exchange, const std::string &routingKey, int flags, const Envelope &envelope);
+    bool publish(const std::string &exchange, const std::string &routingKey, const Envelope &envelope);
 
     /**
      *  Set the Quality of Service (QOS) of the entire connection
@@ -325,20 +311,44 @@ public:
      *  @param  tag                 a consumer tag that will be associated with this consume operation
      *  @param  flags               additional flags
      *  @param  arguments           additional arguments
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+     *
+     *      std::cout << "Started consuming under tag " << tag << std::endl;
+     *
+     *  });
      */
-    bool consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments);
+    DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments);
 
     /**
      *  Cancel a running consumer
      *  @param  tag                 the consumer tag
      *  @param  flags               optional flags
-     *  @return bool
+     *
+     *  This function returns a deferred handler. Callbacks can be installed
+     *  using onSuccess(), onError() and onFinalize() methods.
+     *
+     *  The onSuccess() callback that you can install should have the following signature:
+     *
+     *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+     *
+     *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+     *
+     *      std::cout << "Started consuming under tag " << tag << std::endl;
+     *
+     *  });
      */
-    bool cancel(const std::string &tag, int flags);
+    Deferred<const std::string&>& cancel(const std::string &tag, int flags);
 
     /**
-     *  Acknoledge a message
+     *  Acknowledge a message
      *  @param  deliveryTag         the delivery tag
      *  @param  flags               optional flags
      *  @return bool
@@ -446,24 +456,6 @@ public:
         _callbacks.reportError(message);
     }
 
-    /**
-     *  Report that a consumer has started
-     *  @param  tag     the consumer tag
-     */
-    void reportConsumerStarted(const std::string &tag)
-    {
-        if (_handler) _handler->onConsumerStarted(_parent, tag);
-    }
-
-    /**
-     *  Report that a consumer has stopped
-     *  @param  tag     the consumer tag
-     */
-    void reportConsumerStopped(const std::string &tag)
-    {
-        if (_handler) _handler->onConsumerStopped(_parent, tag);
-    }
-
     /**
      *  Report that a message was received
      */
@@ -475,7 +467,6 @@ public:
      *  @return MessageImpl
      */
     MessageImpl *message(const BasicDeliverFrame &frame);
-    MessageImpl *message(const BasicReturnFrame &frame);
 
     /**
      *  Retrieve the current incoming message
@@ -486,6 +477,20 @@ public:
         return _message;
     }
 
+    /**
+     *  Report that the consumer has started
+     *
+     *  @param  consumerTag the tag under which we are now consuming
+     */
+    void reportConsumerStarted(const std::string& consumerTag)
+    {
+        // if we do not have a consumer, something is very wrong
+        if (!_consumer) reportError("Received basic consume ok frame, but no consumer was found");
+
+        // otherwise, we now report the consumer as started
+        else _consumer->success(consumerTag);
+    }
+
     /**
      *  The channel class is its friend, thus can it instantiate this object
      */
diff --git a/include/deferred.h b/include/deferred.h
index 2d99187..489c537 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -24,16 +24,6 @@ template <typename... Arguments>
 class Deferred
 {
 private:
-    /**
-     *  The channel we operate under
-     */
-    Channel *_channel;
-
-    /**
-     *  Do we already know we failed?
-     */
-    bool _failed;
-
     /**
      *  Callback to execute on success
      */
@@ -49,19 +39,12 @@ private:
      */
     std::function<void(Channel *channel, const std::string& error)> _finalizeCallback;
 
-    /**
-     *  The channel implementation may call our
-     *  private members and construct us
-     */
-    friend class ChannelImpl;
-    friend class Callbacks;
-
     /**
      *  Indicate success
      *
      *  @param  parameters...   the extra parameters relevant for this deferred handler
      */
-    void success(Arguments ...parameters)
+    void success(Arguments ...parameters) const
     {
         // execute callbacks if registered
         if (_successCallback)   _successCallback(_channel, parameters...);
@@ -84,7 +67,24 @@ private:
     }
 
     /**
-     *  Private constructor that can only be called
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+    friend class Callbacks;
+protected:
+    /**
+     *  The channel we operate under
+     */
+    Channel *_channel;
+
+    /**
+     *  Do we already know we failed?
+     */
+    bool _failed;
+
+    /**
+     *  Protected constructor that can only be called
      *  from within the channel implementation
      *
      *  @param  channel the channel we operate under
diff --git a/src/basiccancelokframe.h b/src/basiccancelokframe.h
index 0841379..6d9d42f 100644
--- a/src/basiccancelokframe.h
+++ b/src/basiccancelokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a basic cancel ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -42,7 +42,7 @@ public:
      *
      *  @param  frame   received frame
      */
-    BasicCancelOKFrame(ReceivedFrame &frame) : 
+    BasicCancelOKFrame(ReceivedFrame &frame) :
         BasicFrame(frame),
         _consumerTag(frame)
     {}
@@ -89,13 +89,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
+        if (!channel) return false;
+
         // report
-        channel->reportConsumerStopped(consumerTag());
-        
+        channel->reportSuccess<const std::string&>(consumerTag());
+
         // done
         return true;
     }
diff --git a/src/basicconsumeokframe.h b/src/basicconsumeokframe.h
index cf7298a..1ed8ef4 100644
--- a/src/basicconsumeokframe.h
+++ b/src/basicconsumeokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a basic consume ok frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -52,7 +52,7 @@ public:
      *
      *  @param frame    received frame
      */
-    BasicConsumeOKFrame(ReceivedFrame &frame) : 
+    BasicConsumeOKFrame(ReceivedFrame &frame) :
         BasicFrame(frame),
         _consumerTag(frame)
     {}
@@ -89,13 +89,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
+        if (!channel) return false;
+
         // report
         channel->reportConsumerStarted(consumerTag());
-        
+
         // done
         return true;
     }
diff --git a/src/basicreturnframe.h b/src/basicreturnframe.h
index 1759240..6bb8aef 100644
--- a/src/basicreturnframe.h
+++ b/src/basicreturnframe.h
@@ -144,17 +144,8 @@ public:
      */
     virtual bool process(ConnectionImpl *connection) override
     {
-        // we need the appropriate channel
-        ChannelImpl *channel = connection->channel(this->channel());
-        
-        // channel does not exist
-        if (!channel) return false;    
-        
-        // construct the message
-        channel->message(*this);
-        
-        // done
-        return true;
+        // we no longer support returned messages
+        return false;
     }
 };
 
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 10ea529..f65237f 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -48,10 +48,9 @@ namespace AMQP {
  *  @param  connection
  *  @param  handler
  */
-ChannelImpl::ChannelImpl(Channel *parent, Connection *connection, ChannelHandler *handler) :
+ChannelImpl::ChannelImpl(Channel *parent, Connection *connection) :
     _parent(parent),
-    _connection(&connection->_implementation),
-    _handler(handler)
+    _connection(&connection->_implementation)
 {
     // add the channel to the connection
     _id = _connection->add(this);
@@ -61,9 +60,6 @@ ChannelImpl::ChannelImpl(Channel *parent, Connection *connection, ChannelHandler
     {
         // this is invalid
         _state = state_closed;
-
-        // invalid id, this channel can not exist
-        handler->onError(_parent, "Max number of channels reached");
     }
     else
     {
@@ -352,19 +348,13 @@ Deferred<uint32_t>& ChannelImpl::removeQueue(const std::string &name, int flags)
 /**
  *  Publish a message to an exchange
  *
- *  The following flags can be used
- *
- *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
- *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
- *
  *  @param  exchange    the exchange to publish to
  *  @param  routingkey  the routing key
- *  @param  flags       optional flags (see above)
  *  @param  envelope    the full envelope to send
  *  @param  message     the message to send
  *  @param  size        size of the message
  */
-bool ChannelImpl::publish(const std::string &exchange, const std::string &routingKey, int flags, const Envelope &envelope)
+bool ChannelImpl::publish(const std::string &exchange, const std::string &routingKey, const Envelope &envelope)
 {
     // we are going to send out multiple frames, each one will trigger a call to the handler,
     // which in turn could destruct the channel object, we need to monitor that
@@ -373,7 +363,7 @@ bool ChannelImpl::publish(const std::string &exchange, const std::string &routin
     // @todo do not copy the entire buffer to individual frames
 
     // send the publish frame
-    if (!send(BasicPublishFrame(_id, exchange, routingKey, flags & mandatory, flags & immediate))) return false;
+    if (!send(BasicPublishFrame(_id, exchange, routingKey))) return false;
 
     // channel still valid?
     if (!monitor.valid()) return false;
@@ -432,27 +422,65 @@ Deferred<>& ChannelImpl::setQos(uint16_t prefetchCount)
  *  @param  tag                 a consumer tag that will be associated with this consume operation
  *  @param  flags               additional flags
  *  @param  arguments           additional arguments
- *  @return bool
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
+ *
+ *  The onSuccess() callback that you can install should have the following signature:
+ *
+ *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+ *
+ *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+ *
+ *      std::cout << "Started consuming under tag " << tag << std::endl;
+ *
+ *  });
  */
-bool ChannelImpl::consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments)
+DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments)
 {
-    // send a consume frame
-    return send(BasicConsumeFrame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments));
+    // create the deferred consumer
+    _consumer = std::unique_ptr<DeferredConsumer>(new DeferredConsumer(_parent, false));
+
+    // can we send the basic consume frame?
+    if (!send(BasicConsumeFrame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments)))
+    {
+        // we set the consumer to be failed immediately
+        _consumer->_failed = true;
+
+        // we should call the error function later
+        // TODO
+    }
+
+    // return the consumer
+    return *_consumer;
 }
 
 /**
  *  Cancel a running consumer
  *  @param  tag                 the consumer tag
  *  @param  flags               optional flags
+ *
+ *  This function returns a deferred handler. Callbacks can be installed
+ *  using onSuccess(), onError() and onFinalize() methods.
+ *
+ *  The onSuccess() callback that you can install should have the following signature:
+ *
+ *      void myCallback(AMQP::Channel *channel, const std::string& tag);
+ *
+ *  For example: channel.declareQueue("myqueue").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+ *
+ *      std::cout << "Started consuming under tag " << tag << std::endl;
+ *
+ *  });
  */
-bool ChannelImpl::cancel(const std::string &tag, int flags)
+Deferred<const std::string&>& ChannelImpl::cancel(const std::string &tag, int flags)
 {
     // send a cancel frame
-    return send(BasicCancelFrame(_id, tag, flags & nowait));
+    return send<const std::string&>(BasicCancelFrame(_id, tag, flags & nowait), "Cannot send basic cancel frame");
 }
 
 /**
- *  Acknoledge a message
+ *  Acknowledge a message
  *  @param  deliveryTag         the delivery tag
  *  @param  flags               optional flags
  *  @return bool
@@ -541,14 +569,23 @@ void ChannelImpl::reportMessage()
     // skip if there is no message
     if (!_message) return;
 
-    // after the report the channel may be destructed, monitor that
-    Monitor monitor(this);
+    // do we even have a consumer?
+    if (!_consumer)
+    {
+        // this should not be possible: receiving a message without doing a consume() call
+        reportError("Received message without having a consumer");
+    }
+    else
+    {
+        // after the report the channel may be destructed, monitor that
+        Monitor monitor(this);
 
-    // do we have a handler?
-    if (_handler) _message->report(_parent, _handler);
+        // send message to the consumer
+        _message->report(*_consumer);
 
-    // skip if channel was destructed
-    if (!monitor.valid()) return;
+        // skip if channel was destructed
+        if (!monitor.valid()) return;
+    }
 
     // no longer need the message
     delete _message;
@@ -569,20 +606,6 @@ MessageImpl *ChannelImpl::message(const BasicDeliverFrame &frame)
     return _message = new ConsumedMessage(frame);
 }
 
-/**
- *  Create an incoming message
- *  @param  frame
- *  @return MessageImpl
- */
-MessageImpl *ChannelImpl::message(const BasicReturnFrame &frame)
-{
-    // it should not be possible that a message already exists, but lets check it anyhow
-    if (_message) delete _message;
-
-    // construct a message
-    return _message = new ReturnedMessage(frame);
-}
-
 /**
  *  End of namespace
  */
diff --git a/src/consumedmessage.h b/src/consumedmessage.h
index 30ed208..2227763 100644
--- a/src/consumedmessage.h
+++ b/src/consumedmessage.h
@@ -26,7 +26,7 @@ private:
      *  @var uint64_t
      */
     uint64_t _deliveryTag;
-    
+
     /**
      *  Is this a redelivered message?
      *  @var bool
@@ -39,25 +39,24 @@ public:
      *  Constructor
      *  @param  frame
      */
-    ConsumedMessage(const BasicDeliverFrame &frame) : 
-        MessageImpl(frame.exchange(), frame.routingKey()), 
+    ConsumedMessage(const BasicDeliverFrame &frame) :
+        MessageImpl(frame.exchange(), frame.routingKey()),
         _consumerTag(frame.consumerTag()), _deliveryTag(frame.deliveryTag()), _redelivered(frame.redelivered())
     {}
-        
+
     /**
      *  Destructor
      */
     virtual ~ConsumedMessage() {}
-    
+
     /**
      *  Report to the handler
-     *  @param  channel
-     *  @param  handler
+     *  @param  consumer
      */
-    virtual void report(Channel *channel, ChannelHandler *handler) override
+    virtual void report(const DeferredConsumer& consumer) override
     {
-        // report to the handler
-        handler->onReceived(channel, *this, _deliveryTag, _consumerTag, _redelivered);
+        // send ourselves to the consumer
+        consumer.message(*this, _deliveryTag, _consumerTag, _redelivered);
     }
 };
 
diff --git a/src/messageimpl.h b/src/messageimpl.h
index 27d5b85..1b087dd 100644
--- a/src/messageimpl.h
+++ b/src/messageimpl.h
@@ -20,10 +20,10 @@ class MessageImpl : public Message
 private:
     /**
      *  How many bytes have been received?
-     *  @var uint64_t 
+     *  @var uint64_t
      */
     uint64_t _received;
-    
+
     /**
      *  Was the buffer allocated by us?
      *  @var bool
@@ -36,8 +36,8 @@ protected:
      *  @param  exchange
      *  @param  routingKey
      */
-    MessageImpl(const std::string &exchange, const std::string &routingKey) : 
-        Message(exchange, routingKey), 
+    MessageImpl(const std::string &exchange, const std::string &routingKey) :
+        Message(exchange, routingKey),
         _received(0), _selfAllocated(false)
         {}
 
@@ -45,12 +45,12 @@ public:
     /**
      *  Destructor
      */
-    virtual ~MessageImpl() 
+    virtual ~MessageImpl()
     {
         // clear up memory if it was self allocated
         if (_selfAllocated) delete[] _body;
     }
-    
+
     /**
      *  Set the body size
      *  This field is set when the header is received
@@ -60,7 +60,7 @@ public:
     {
         _bodySize = size;
     }
-    
+
     /**
      *  Append data
      *  @param  buffer      incoming data
@@ -84,27 +84,26 @@ public:
             // it does not yet fit, do we have to allocate?
             if (!_body) _body = new char[_bodySize];
             _selfAllocated = true;
-            
+
             // prevent that size is too big
             if (size > _bodySize - _received) size = _bodySize - _received;
-            
+
             // append data
             memcpy((char *)(_body + _received), buffer, size);
-            
+
             // we have more data now
             _received += size;
-            
+
             // done
             return _received >= _bodySize;
         }
     }
-    
+
     /**
      *  Report to the handler
-     *  @param  channel
-     *  @param  handler
+     *  @param  consumer
      */
-    virtual void report(Channel *channel, ChannelHandler *handler) = 0;
+    virtual void report(const DeferredConsumer& consumer) = 0;
 };
 
 /**
diff --git a/src/returnedmessage.h b/src/returnedmessage.h
index 61115d7..322bb88 100644
--- a/src/returnedmessage.h
+++ b/src/returnedmessage.h
@@ -24,7 +24,7 @@ private:
      *  @var    int16_t
      */
     int16_t _replyCode;
-    
+
     /**
      *  The reply message
      *  @var    string
@@ -40,21 +40,19 @@ public:
     ReturnedMessage(const BasicReturnFrame &frame) :
         MessageImpl(frame.exchange(), frame.routingKey()),
         _replyCode(frame.replyCode()), _replyText(frame.replyText()) {}
-        
+
     /**
      *  Destructor
      */
     virtual ~ReturnedMessage() {}
-    
+
     /**
      *  Report to the handler
-     *  @param  channel
-     *  @param  handler
+     *  @param  consumer
      */
-    virtual void report(Channel *channel, ChannelHandler *handler) override
+    virtual void report(const DeferredConsumer& consumer) override
     {
-        // report to the handler
-        handler->onReturned(channel, *this, _replyCode, _replyText);
+        // we no longer support returned messages
     }
 };
 
diff --git a/tests/main.cpp b/tests/main.cpp
index 49076b7..f0c1b04 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -30,13 +30,13 @@ using namespace Copernica;
  *  @return int
  */
 int main(int argc, const char *argv[])
-{   
+{
     // need an ip
     if (argc != 2)
     {
         // report error
         std::cerr << "usage: " << argv[0] << " <ip>" << std::endl;
-        
+
         // done
         return -1;
     }
diff --git a/tests/myconnection.cpp b/tests/myconnection.cpp
index 64c82b4..7234ad7 100644
--- a/tests/myconnection.cpp
+++ b/tests/myconnection.cpp
@@ -3,13 +3,13 @@
  *
  *  @copyright 2014 Copernica BV
  */
- 
+
 /**
  *  Required external libraries
  */
 #include <amqpcpp.h>
 #include <copernica/network.h>
- 
+
 #include <string>
 
 /**
@@ -17,7 +17,7 @@
  */
 using namespace std;
 using namespace Copernica;
- 
+
 /**
  *  Required local class definitions
  */
@@ -33,23 +33,11 @@ MyConnection::MyConnection(const std::string &ip) :
 {
     // start connecting
     if (_socket.connect(Network::Ipv4Address(ip), 5672)) return;
-    
+
     // failure
     onFailure(&_socket);
 }
 
-/**
- *  Destructor
- */
-MyConnection::~MyConnection()
-{
-    // do we still have a channel?
-    if (_channel)  delete _channel;
-    
-    // do we still have a connection?
-    if (_connection) delete _connection;
-}
-
 /**
  *  Method that is called when the connection failed
  *  @param  socket      Pointer to the socket
@@ -78,19 +66,118 @@ void MyConnection::onConnected(Network::TcpSocket *socket)
 {
     // report connection
     std::cout << "connected" << std::endl;
-    
+
     // we are connected, leap out if there already is a amqp connection
     if (_connection) return;
-    
+
     // create amqp connection, and a new channel
-    _connection = new AMQP::Connection(this, AMQP::Login("guest", "guest"), "/");
-    _channel = new AMQP::Channel(_connection, this);
-    
-    // we declare a queue, an exchange and we publish a message
-    _channel->declareQueue("my_queue");
-//    _channel->declareQueue("my_queue", AMQP::autodelete);
-    _channel->declareExchange("my_exchange", AMQP::direct);
-    _channel->bindQueue("my_exchange", "my_queue", "key");
+    _connection = std::unique_ptr<AMQP::Connection>(new AMQP::Connection(this, AMQP::Login("guest", "guest"), "/"));
+    _channel = std::unique_ptr<AMQP::Channel>(new AMQP::Channel(_connection.get()));
+
+    // watch for the channel becoming ready
+    _channel->onReady([](AMQP::Channel *channel) {
+        // show that we are ready
+        std::cout << "AMQP channel ready, id: " << (int) channel->id() << std::endl;
+    });
+
+    // and of course for channel errors
+    _channel->onError([this](AMQP::Channel *channel, const std::string& message) {
+        // inform the user of the error
+        std::cerr << "AMQP channel error on channel " << channel->id() << ": " << message << std::endl;
+
+        // delete the channel
+        _channel = nullptr;
+
+        // close the connection
+        _connection->close();
+    });
+
+    // declare a queue and let us know when it succeeds
+    _channel->declareQueue("my_queue").onSuccess([](AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount){
+        // queue was successfully declared
+        std::cout << "AMQP Queue declared with name '" << name << "', " << messageCount << " messages and " << consumerCount << " consumer" << std::endl;
+    });
+
+    // also declare an exchange
+    _channel->declareExchange("my_exchange", AMQP::direct).onSuccess([](AMQP::Channel *channel) {
+        // exchange successfully declared
+        std::cout << "AMQP exchange declared" << std::endl;
+    });
+
+    // bind the queue to the exchange
+    _channel->bindQueue("my_exchange", "my_queue", "key").onSuccess([](AMQP::Channel *channel) {
+        // queue successfully bound to exchange
+        std::cout << "AMQP Queue bound" << std::endl;
+    });
+
+    // set quality of service
+    _channel->setQos(1).onSuccess([](AMQP::Channel *channel) {
+        // quality of service successfully set
+        std::cout << "AMQP Quality of Service set" << std::endl;
+    });
+
+    // publish a message to the exchange
+    if (!_channel->publish("my_exchange", "key", "my_message"))
+    {
+        // we could not publish the message, something is wrong somewhere
+        std::cerr << "Unable to publish message" << std::endl;
+
+        // close the channel
+        _channel->close().onSuccess([this](AMQP::Channel *channel) {
+            // also close the connection
+            _connection->close();
+        });
+    }
+
+    // consume the message we just published
+    _channel->consume("my_queue", "my_consumer", AMQP::exclusive)
+    .onReceived([this](AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {
+        // show the message data
+        std::cout << "AMQP consumed: " << message.message() << std::endl;
+
+        // ack the message
+        _channel->ack(deliveryTag);
+
+        // and stop consuming (there is only one message anyways)
+        _channel->cancel("my_consumer").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+            // we successfully stopped consuming
+            std::cout << "Stopped consuming under tag " << tag << std::endl;
+        });
+
+        // unbind the queue again
+        _channel->unbindQueue("my_exchange", "my_queue", "key").onSuccess([](AMQP::Channel *channel) {
+            // queueu successfully unbound
+            std::cout << "Queue unbound" << std::endl;
+        });
+
+        // the queue should now be empty, so we can delete it
+        _channel->removeQueue("my_queue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
+            // queue was removed, it should have been empty, so messageCount should be 0
+            if (messageCount) std::cerr << "Removed queue which should have been empty but contained " << messageCount << " messages" << std::endl;
+
+            // no messages is the expected behavior
+            else std::cout << "Queue removed" << std::endl;
+        });
+
+        // also remove the exchange
+        _channel->removeExchange("my_exchange").onSuccess([](AMQP::Channel *channel) {
+            // exchange was successfully removed
+            std::cout << "Removed exchange" << std::endl;
+        });
+
+        // everything done, close the channel
+        _channel->close().onSuccess([this](AMQP::Channel *channel) {
+            // channel was closed
+            std::cout << "Channel closed" << std::endl;
+
+            // close the connection too
+            _connection->close();
+        });
+    })
+    .onSuccess([](AMQP::Channel *channel, const std::string& tag) {
+        // consumer was started
+        std::cout << "Started consuming under tag " << tag << std::endl;
+    });
 }
 
 /**
@@ -103,12 +190,11 @@ void MyConnection::onClosed(Network::TcpSocket *socket)
     std::cout << "myconnection closed" << std::endl;
 
     // close the channel and connection
-    if (_channel) delete _channel;
-    if (_connection) delete _connection;
-    
-    // set to null
     _channel = nullptr;
     _connection = nullptr;
+
+    // stop the loop
+    Event::MainLoop::instance()->stop();
 }
 
 /**
@@ -119,14 +205,13 @@ void MyConnection::onLost(Network::TcpSocket *socket)
 {
     // report error
     std::cout << "connection lost" << std::endl;
-    
+
     // close the channel and connection
-    if (_channel) delete _channel;
-    if (_connection) delete _connection;
-    
-    // set to null
     _channel = nullptr;
     _connection = nullptr;
+
+    // stop the loop
+    Event::MainLoop::instance()->stop();
 }
 
 /**
@@ -136,15 +221,12 @@ void MyConnection::onLost(Network::TcpSocket *socket)
  */
 void MyConnection::onData(Network::TcpSocket *socket, Network::Buffer *buffer)
 {
-    // send what came in
-    std::cout << "received: " << buffer->size() << " bytes" << std::endl;
-    
     // leap out if there is no connection
     if (!_connection) return;
-    
+
     // let the data be handled by the connection
     size_t bytes = _connection->parse(buffer->data(), buffer->size());
-    
+
     // shrink the buffer
     buffer->shrink(bytes);
 }
@@ -152,7 +234,7 @@ void MyConnection::onData(Network::TcpSocket *socket, Network::Buffer *buffer)
 /**
  *  Method that is called when data needs to be sent over the network
  *
- *  Note that the AMQP library does no buffering by itself. This means 
+ *  Note that the AMQP library does no buffering by itself. This means
  *  that this method should always send out all data or do the buffering
  *  itself.
  *
@@ -162,21 +244,27 @@ void MyConnection::onData(Network::TcpSocket *socket, Network::Buffer *buffer)
  */
 void MyConnection::onData(AMQP::Connection *connection, const char *buffer, size_t size)
 {
-//    // report what is going on
-//    std::cout << "send: " << size << std::endl;
-//    
-//    for (unsigned i=0; i<size; i++) std::cout << (int)buffer[i] << " ";
-//    std::cout << std::endl;
-    
-    
     // send to the socket
     _socket.write(buffer, size);
 }
 
+/**
+ *  Method that is called when the connection to AMQP was closed
+ *  @param  connection  pointer to connection object
+ */
+void MyConnection::onClosed(AMQP::Connection *connection)
+{
+    // report that AMQP connection is closed
+    std::cout << "AMQP connection closed" << std::endl;
+
+    // close the underlying socket
+    _socket.close();
+}
+
 /**
  *  When the connection ends up in an error state this method is called.
  *  This happens when data comes in that does not match the AMQP protocol
- *  
+ *
  *  After this method is called, the connection no longer is in a valid
  *  state and can be used. In normal circumstances this method is not called.
  *
@@ -199,265 +287,7 @@ void MyConnection::onConnected(AMQP::Connection *connection)
 {
     // show
     std::cout << "AMQP login success" << std::endl;
-    
+
     // create channel if it does not yet exist
-    if (!_channel) _channel = new AMQP::Channel(connection, this);
+    if (!_channel) _channel = std::unique_ptr<AMQP::Channel>(new AMQP::Channel(connection));
 }
-
-/**
- *  Method that is called when the channel was succesfully created.
- *  Only after the channel was created, you can use it for subsequent messages over it
- *  @param  channel
- */
-void MyConnection::onReady(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP channel ready, id: " << (int) channel->id() << std::endl;
-}
-
-/**
- *  An error has occured on the channel
- *  @param  channel
- *  @param  message
- */
-
-void MyConnection::onError(AMQP::Channel *channel, const std::string &message)
-{
-    // show
-    std::cout << "AMQP channel error, id: " << (int) channel->id() << " - message: " << message << std::endl;
-
-    // main channel cause an error, get rid of if
-    delete _channel;
-
-    // reset pointer
-    _channel = nullptr;
-}
-    
-/**
- *  Method that is called when the channel was paused
- *  @param  channel
- */
-void MyConnection::onPaused(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP channel paused" << std::endl;
-}
-
-/**
- *  Method that is called when the channel was resumed
- *  @param  channel
- */
-void MyConnection::onResumed(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP channel resumed" << std::endl;
-}
-
-/**
- *  Method that is called when a channel is closed
- *  @param  channel
- */
-void MyConnection::onClosed(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP channel closed" << std::endl;
-}
-
-/**
- *  Method that is called when a transaction was started
- *  @param  channel
- */
-void MyConnection::onTransactionStarted(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP transaction started" << std::endl;
-}
-
-/**
- *  Method that is called when a transaction was committed
- *  @param  channel
- */
-void MyConnection::onTransactionCommitted(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP transaction committed" << std::endl;
-}
-
-/**
- *  Method that is called when a transaction was rolled back
- *  @param  channel
- */
-void MyConnection::onTransactionRolledBack(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP transaction rolled back" << std::endl;
-}
-
-/**
- *  Mehod that is called when an exchange is declared
- *  @param  channel
- */
-void MyConnection::onExchangeDeclared(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP exchange declared" << std::endl;
-}
-
-/**
- *  Method that is called when an exchange is bound
- *  @param  channel
- */
-void MyConnection::onExchangeBound(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Exchange bound" << std::endl;
-}
-
-/**
- *  Method that is called when an exchange is unbound
- *  @param  channel
- */
-void MyConnection::onExchangeUnbound(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Exchange unbound" << std::endl;
-}
-
-/**
- *  Method that is called when an exchange is deleted
- *  @param  channel
- */
-void MyConnection::onExchangeDeleted(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Exchange deleted" << std::endl;
-}
-
-/**
- *  Method that is called when a queue is declared
- *  @param  channel
- *  @param  name            name of the queue
- *  @param  messageCount    number of messages in queue
- *  @param  consumerCount   number of active consumers
- */
-void MyConnection::onQueueDeclared(AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount)
-{
-    // show
-    std::cout << "AMQP Queue declared" << std::endl;
-}
-
-/**
- *  Method that is called when a queue is bound
- *  @param  channel
- *  @param  
- */
-void MyConnection::onQueueBound(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Queue bound" << std::endl;
-
-//    _connection->setQos(10);
-//    _channel->setQos(1);
-
-
-    _channel->publish("my_exchange", "invalid-key", AMQP::mandatory, "this is the message");
-//    _channel->consume("my_queue");
-}
-
-/**
- *  Method that is called when a queue is deleted
- *  @param  channel
- *  @param  messageCount    number of messages deleted along with the queue
- */
-void MyConnection::onQueueDeleted(AMQP::Channel *channel, uint32_t messageCount)
-{
-    // show
-    std::cout << "AMQP Queue deleted" << std::endl;
-}
-
-/**
- *  Method that is called when a queue is unbound
- *  @param  channel
- */
-void MyConnection::onQueueUnbound(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Queue unbound" << std::endl;
-}
-
-/**
- *  Method that is called when a queue is purged
- *  @param  messageCount        number of message purged
- */
-void MyConnection::onQueuePurged(AMQP::Channel *channel, uint32_t messageCount)
-{
-    // show
-    std::cout << "AMQP Queue purged" << std::endl;
-}
-
-/**
- *  Method that is called when the quality-of-service was changed
- *  This is the result of a call to Channel::setQos()
- */
-void MyConnection::onQosSet(AMQP::Channel *channel)
-{
-    // show
-    std::cout << "AMQP Qos set" << std::endl;
-}
-
-/**
- *  Method that is called when a consumer was started
- *  This is the result of a call to Channel::consume()
- *  @param  channel         the channel on which the consumer was started
- *  @param  tag             the consumer tag
- */
-void MyConnection::onConsumerStarted(AMQP::Channel *channel, const std::string &tag)
-{
-    // show
-    std::cout << "AMQP consumer started" << std::endl;
-}
-
-/**
- *  Method that is called when a message has been received on a channel
- *  @param  channel         the channel on which the consumer was started
- *  @param  message         the consumed message
- *  @param  deliveryTag     the delivery tag, you need this to acknowledge the message
- *  @param  consumerTag     the consumer identifier that was used to retrieve this message
- *  @param  redelivered     is this a redelivered message?
- */
-void MyConnection::onReceived(AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)
-{
-    // show
-    std::cout << "AMQP consumed: " << message.message() << std::endl;
-    
-    // ack the message
-    channel->ack(deliveryTag);
-}
-
-/**
- *  Method that is called when a message you tried to publish was returned
- *  by the server. This only happens when the 'mandatory' or 'immediate' flag
- *  was set with the Channel::publish() call.
- *  @param  channel         the channel on which the message was returned
- *  @param  message         the returned message
- *  @param  code            the reply code
- *  @param  text            human readable reply reason
- */
-void MyConnection::onReturned(AMQP::Channel *channel, const AMQP::Message &message, int16_t code, const std::string &text)
-{
-    // show
-    std::cout << "AMQP message returned: " << text << std::endl;
-}
-
-/**
- *  Method that is called when a consumer was stopped
- *  This is the result of a call to Channel::cancel()
- *  @param  channel         the channel on which the consumer was stopped
- *  @param  tag             the consumer tag
- */
-void MyConnection::onConsumerStopped(AMQP::Channel *channel, const std::string &tag)
-{
-    // show
-    std::cout << "AMQP consumer stopped" << std::endl;
-}
-
diff --git a/tests/myconnection.h b/tests/myconnection.h
index 61b0e1e..698428b 100644
--- a/tests/myconnection.h
+++ b/tests/myconnection.h
@@ -9,9 +9,8 @@
 /**
  *  Class definition
  */
-class MyConnection : 
+class MyConnection :
     public AMQP::ConnectionHandler,
-    public AMQP::ChannelHandler,
     public Network::TcpHandler
 {
 private:
@@ -20,18 +19,18 @@ private:
      *  @var    TcpSocket
      */
     Network::TcpSocket _socket;
-    
+
     /**
      *  The AMQP connection
      *  @var    Connection
      */
-    AMQP::Connection *_connection;
-    
+    std::unique_ptr<AMQP::Connection> _connection;
+
     /**
      *  The AMQP channel
      *  @var    Channel
      */
-    AMQP::Channel *_channel;
+    std::unique_ptr<AMQP::Channel> _channel;
 
     /**
      *  Method that is called when the connection failed
@@ -44,13 +43,13 @@ private:
      *  @param  socket      Pointer to the socket
      */
     virtual void onTimeout(Network::TcpSocket *socket) override;
-    
+
     /**
      *  Method that is called when the connection succeeded
      *  @param  socket      Pointer to the socket
      */
     virtual void onConnected(Network::TcpSocket *socket) override;
-    
+
     /**
      *  Method that is called when the socket is closed (as a result of a TcpSocket::close() call)
      *  @param  socket      Pointer to the socket
@@ -62,18 +61,18 @@ private:
      *  @param  socket      Pointer to the socket
      */
     virtual void onLost(Network::TcpSocket *socket) override;
-    
+
     /**
      *  Method that is called when data is received on the socket
      *  @param  socket      Pointer to the socket
      *  @param  buffer      Pointer to the fill input buffer
      */
     virtual void onData(Network::TcpSocket *socket, Network::Buffer *buffer) override;
-    
+
     /**
      *  Method that is called when data needs to be sent over the network
      *
-     *  Note that the AMQP library does no buffering by itself. This means 
+     *  Note that the AMQP library does no buffering by itself. This means
      *  that this method should always send out all data or do the buffering
      *  itself.
      *
@@ -82,11 +81,17 @@ private:
      *  @param  size            Size of the buffer
      */
     virtual void onData(AMQP::Connection *connection, const char *buffer, size_t size) override;
-    
+
+    /**
+     *  Method that is called when the connection to AMQP was closed
+     *  @param  connection  pointer to connection object
+     */
+    virtual void onClosed(AMQP::Connection *connection) override;
+
     /**
      *  When the connection ends up in an error state this method is called.
      *  This happens when data comes in that does not match the AMQP protocol
-     *  
+     *
      *  After this method is called, the connection no longer is in a valid
      *  state and can be used. In normal circumstances this method is not called.
      *
@@ -103,175 +108,11 @@ private:
      */
     virtual void onConnected(AMQP::Connection *connection) override;
 
-    /**
-     *  Method that is called when the channel was succesfully created.
-     *  Only after the channel was created, you can use it for subsequent messages over it
-     *  @param  channel
-     */
-    virtual void onReady(AMQP::Channel *channel) override;
-    
-    /**
-     *  An error has occured on the channel
-     *  @param  channel
-     *  @param  message
-     */
-    virtual void onError(AMQP::Channel *channel, const std::string &message) override;
-
-    /**
-     *  Method that is called when the channel was paused
-     *  @param  channel
-     */
-    virtual void onPaused(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when the channel was resumed
-     *  @param  channel
-     */
-    virtual void onResumed(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a channel is closed
-     *  @param  channel
-     */
-    virtual void onClosed(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a transaction was started
-     *  @param  channel
-     */
-    virtual void onTransactionStarted(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a transaction was committed
-     *  @param  channel
-     */
-    virtual void onTransactionCommitted(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a transaction was rolled back
-     *  @param  channel
-     */
-    virtual void onTransactionRolledBack(AMQP::Channel *channel) override;
-
-    /**
-     *  Method that is called when an exchange is bound
-     *  @param  channel
-     */
-    virtual void onExchangeBound(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when an exchange is unbound
-     *  @param  channel
-     */
-    virtual void onExchangeUnbound(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when an exchange is deleted
-     *  @param  channel
-     */
-    virtual void onExchangeDeleted(AMQP::Channel *channel) override;
-    
-    /**
-     *  Mehod that is called when an exchange is declared
-     *  @param  channel
-     */
-    virtual void onExchangeDeclared(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a queue is declared
-     *  @param  channel
-     *  @param  name            name of the queue
-     *  @param  messageCount    number of messages in queue
-     *  @param  consumerCount   number of active consumers
-     */
-    virtual void onQueueDeclared(AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount) override;
-    
-    /**
-     *  Method that is called when a queue is bound
-     *  @param  channel
-     *  @param  
-     */
-    virtual void onQueueBound(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a queue is deleted
-     *  @param  channel
-     *  @param  messageCount    number of messages deleted along with the queue
-     */
-    virtual void onQueueDeleted(AMQP::Channel *channel, uint32_t messageCount) override;
-    
-    /**
-     *  Method that is called when a queue is unbound
-     *  @param  channel
-     */
-    virtual void onQueueUnbound(AMQP::Channel *channel) override;
-    
-    /**
-     *  Method that is called when a queue is purged
-     *  @param  messageCount        number of message purged
-     */
-    virtual void onQueuePurged(AMQP::Channel *channel, uint32_t messageCount) override;
-
-    /**
-     *  Method that is called when the quality-of-service was changed
-     *  This is the result of a call to Channel::setQos()
-     */
-    virtual void onQosSet(AMQP::Channel *channel) override;
-
-    /**
-     *  Method that is called when a consumer was started
-     *  This is the result of a call to Channel::consume()
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  tag             the consumer tag
-     */
-    virtual void onConsumerStarted(AMQP::Channel *channel, const std::string &tag) override;
-
-    /**
-     *  Method that is called when a consumer was stopped
-     *  This is the result of a call to Channel::cancel()
-     *  @param  channel         the channel on which the consumer was stopped
-     *  @param  tag             the consumer tag
-     */
-    virtual void onConsumerStopped(AMQP::Channel *channel, const std::string &tag) override;
-    
-    /**
-     *  Method that is called when a message has been received on a channel
-     *  This message will be called for every message that is received after
-     *  you started consuming. Make sure you acknowledge the messages when its
-     *  safe to remove them from RabbitMQ (unless you set no-ack option when you
-     *  started the consumer)
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  message         the consumed message
-     *  @param  deliveryTag     the delivery tag, you need this to acknowledge the message
-     *  @param  consumerTag     the consumer identifier that was used to retrieve this message
-     *  @param  redelivered     is this a redelivered message?
-     */
-    virtual void onReceived(AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) override;
-    
-    /**
-     *  Method that is called when a message you tried to publish was returned
-     *  by the server. This only happens when the 'mandatory' or 'immediate' flag
-     *  was set with the Channel::publish() call.
-     *  @param  channel         the channel on which the message was returned
-     *  @param  message         the returned message
-     *  @param  code            the reply code
-     *  @param  text            human readable reply reason
-     */
-    virtual void onReturned(AMQP::Channel *channel, const AMQP::Message &message, int16_t code, const std::string &text) override;
-
-
 public:
     /**
      *  Constructor
      *  @param  ip
      */
     MyConnection(const std::string &ip);
-    
-    /**
-     *  Destructor
-     */
-    virtual ~MyConnection();
-
-
 };
 

From 3348e2881c17f12dc4360e62052d48abb9bf7928 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Thu, 10 Apr 2014 13:50:24 +0200
Subject: [PATCH 09/41] Updated README

---
 README.md | 334 ++++++++++++++++++++++++------------------------------
 1 file changed, 145 insertions(+), 189 deletions(-)

diff --git a/README.md b/README.md
index 79da95c..ce5468d 100644
--- a/README.md
+++ b/README.md
@@ -1,27 +1,27 @@
 AMQP-CPP
 ========
 
-AMQP-CPP is a C++ library for communicating with a RabbitMQ message broker. The 
-library can be used to parse incoming data from a RabbitMQ server, and to 
+AMQP-CPP is a C++ library for communicating with a RabbitMQ message broker. The
+library can be used to parse incoming data from a RabbitMQ server, and to
 generate frames that can be sent to a RabbitMQ server.
 
 Unlike all other AMQP libraries, this AMQP-CPP library does not make a connection to
-RabbitMQ by itself, nor does it create sockets and/or performs IO operations. As 
-a user of this library, you first need to set up a socket connection 
-to RabbitMQ by yourself, and implement a certain interface that you pass to the 
+RabbitMQ by itself, nor does it create sockets and/or performs IO operations. As
+a user of this library, you first need to set up a socket connection
+to RabbitMQ by yourself, and implement a certain interface that you pass to the
 AMQP-CPP library and that the library will use for IO operations.
 
 This architecture makes the library extremely flexible: it does not rely on
 operating system specific IO calls, and it can be easily integrated into any
-event loop. It is fully asynchronous and does not do any blocking (system) calls, 
+event loop. It is fully asynchronous and does not do any blocking (system) calls,
 so it can be used in high performance applications without the need for threads.
 
 
 ABOUT
 =====
 
-This library is created and maintained by Copernica (www.copernica.com), and is 
-used inside the MailerQ (www.mailerq.com) application, MailerQ is a tool for 
+This library is created and maintained by Copernica (www.copernica.com), and is
+used inside the MailerQ (www.mailerq.com) application, MailerQ is a tool for
 sending large volumes of email, using AMQP message queues.
 
 
@@ -42,34 +42,34 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
 {
     /**
      *  Method that is called by the AMQP library every time it has data
-     *  available that should be sent to RabbitMQ. 
-     *  @param  connection  pointer to the main connection object  
+     *  available that should be sent to RabbitMQ.
+     *  @param  connection  pointer to the main connection object
      *  @param  data        memory buffer with the data that should be sent to RabbitMQ
      *  @param  size        size of the buffer
      */
     virtual void onData(AMQP::Connection *connection, const char *data, size_t size)
     {
-        // @todo 
+        // @todo
         //  Add your own implementation, for example by doing a call to the
         //  send() system call. But be aware that the send() call may not
         //  send all data at once, so you also need to take care of buffering
-        //  the bytes that could not immediately be sent, and try to send 
+        //  the bytes that could not immediately be sent, and try to send
         //  them again when the socket becomes writable again
     }
-    
+
     /**
-     *  Method that is called by the AMQP library when the login attempt 
-     *  succeeded. After this method has been called, the connection is ready 
+     *  Method that is called by the AMQP library when the login attempt
+     *  succeeded. After this method has been called, the connection is ready
      *  to use.
      *  @param  connection      The connection that can now be used
      */
     virtual void onConnected(AMQP::Connection *connection)
     {
         // @todo
-        //  add your own implementation, for example by creating a channel 
+        //  add your own implementation, for example by creating a channel
         //  instance, and start publishing or consuming
     }
-    
+
     /**
      *  Method that is called by the AMQP library when a fatal error occurs
      *  on the connection, for example because data received from RabbitMQ
@@ -81,7 +81,7 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
     {
         // @todo
         //  add your own implementation, for example by reporting the error
-        //  to the user of your program, log the error, and destruct the 
+        //  to the user of your program, log the error, and destruct the
         //  connection object because it is no longer in a usable state
     }
 };
@@ -108,18 +108,18 @@ channel.bindQueue("my-exchange", "my-queue");
 A number of remarks about the example above. First you may have noticed that we've
 created all objects on the stack. You are of course also free to create them
 on the heap with the C++ operator 'new'. That works just as well, and is in real
-life code probably more useful as you normally want to keep your handlers, connection 
+life code probably more useful as you normally want to keep your handlers, connection
 and channel objects around for a much longer time.
 
-But more importantly, you can see in the example above that we have created the 
-channel object directly after we made the connection object, and we also 
+But more importantly, you can see in the example above that we have created the
+channel object directly after we made the connection object, and we also
 started declaring exchanges and queues right away. However, under the hood, a handshake
 protocol is executed between the server and the client when the Connection
 object is first created. During this handshake procedure it is not permitted to send
-other instructions (like opening a channel or declaring a queue). It would therefore have been better 
-if we had first waited for the connection to be ready (implement the MyConnectionHandler::onConnected() method), 
-and create the channel object only then. But this is not strictly necessary. 
-The methods that are called before the handshake is completed are cached by the 
+other instructions (like opening a channel or declaring a queue). It would therefore have been better
+if we had first waited for the connection to be ready (implement the MyConnectionHandler::onConnected() method),
+and create the channel object only then. But this is not strictly necessary.
+The methods that are called before the handshake is completed are cached by the
 AMQP library and will be executed the moment the handshake is completed and the
 connection becomes ready for use.
 
@@ -128,15 +128,15 @@ PARSING INCOMING DATA
 =====================
 
 The ConnectionHandler class has a method onData() that is called by the library
-every time that it wants to send out data. We've explained that it is up to you to 
-implement that method. But what about data in the other direction? How does the 
+every time that it wants to send out data. We've explained that it is up to you to
+implement that method. But what about data in the other direction? How does the
 library receive data back from RabbitMQ?
 
-As we've explained above, the AMQP-CPP library does not do any IO by itself 
-and it is therefore of course also not possible for the library to receive data from 
-a socket. It is again up to you to do this. If, for example, you notice in your 
-event loop that the socket that is connected with the RabbitMQ server becomes 
-readable, you should read out that data (for example by using the recv() system 
+As we've explained above, the AMQP-CPP library does not do any IO by itself
+and it is therefore of course also not possible for the library to receive data from
+a socket. It is again up to you to do this. If, for example, you notice in your
+event loop that the socket that is connected with the RabbitMQ server becomes
+readable, you should read out that data (for example by using the recv() system
 call), and pass the received bytes to the AMQP-CPP library. This is done by
 calling the parse() method in the Connection object.
 
@@ -147,7 +147,7 @@ The code snippet below comes from the Connection.h C++ header file.
 ````c++
 /**
  *  Parse data that was recevied from RabbitMQ
- *  
+ *
  *  Every time that data comes in from RabbitMQ, you should call this method to parse
  *  the incoming data, and let it handle by the AMQP-CPP library. This method returns the number
  *  of bytes that were processed.
@@ -170,36 +170,42 @@ size_t parse(char *buffer, size_t size)
 CHANNELS
 ========
 
-In the example you saw that we created a channel object. A channel is a virtual 
-connection over a single TCP connection, and it is possible to create many channels 
+In the example you saw that we created a channel object. A channel is a virtual
+connection over a single TCP connection, and it is possible to create many channels
 that all use the same TCP connection.
 
-AMQP instructions are always sent over a channel, so before you can send the first 
-command to the RabbitMQ server, you first need a channel object. The channel 
+AMQP instructions are always sent over a channel, so before you can send the first
+command to the RabbitMQ server, you first need a channel object. The channel
 object has many methods to send instructions to the RabbitMQ server. It for
-example has methods to declare queues and exchanges, to bind and unbind them, 
-and to publish and consume messages. You can best take a look at the channel.h 
-C++ header file for a list of all available methods. Every method in it is well 
+example has methods to declare queues and exchanges, to bind and unbind them,
+and to publish and consume messages. You can best take a look at the channel.h
+C++ header file for a list of all available methods. Every method in it is well
 documented.
 
-The constructor of the Channel object accepts two parameters: the connection object,
-and a pointer to a ChannelHandler object. In the example we did 
-not use this ChannelHandler object. However, in normal circumstances, you should 
-always pass a pointer to a ChannelHandler object every time you construct a channel. 
-
-Just like the ConnectionHandler class, the ChannelHandler class is a base class that 
-you can extend to override the virtual methods you need. The AMQP library 
-will call these methods to inform you that an operation on the channel has succeeded 
-or has failed.
+The constructor of the Channel object accepts one parameter: the connection object.
+Unlike the connection it does not accept a handler. Instead of this (almost) every
+function in the channel returns a Deferred object. This deferred object can be used
+to install handlers to be called in case of success, failure or in either case.
 
 For example, if you call the channel.declareQueue() method, the AMQP-CPP library will
 send a message to the RabbitMQ message broker to ask it to declare the
 queue. However, because all operations in the library are asynchronous, the
 declareQueue() method immediately returns 'true', although it is at that time
 not yet known whether the queue was correctly declared. Only after a while,
-after the instruction has reached the server, and the confirmation from the server 
-has been sent back to the client, your ChannelHandler::onQueueDeclared()
-method will be called to inform you that the operation was succesful.
+after the instruction has reached the server, and the confirmation from the server
+has been sent back to the client, your handler method will be called to inform
+you that the operation was succesful.
+
+````c++
+Channel myChannel(&connection);
+myChannel.declareQueue("my-queue")
+.onSuccess([](AMQP::Channel *channel, const std::string& name, uint32_t messageCount, uint32_t consumerCount) {
+    // by now the queue is created
+})
+.onError([](AMQP::Channel *channel, const std::string message) {
+    // something went wrong creating the channel
+});
+````
 
 It is important to realize that any error that occurs on a channel, will
 invalidate the entire channel,. including all subsequent instructions that
@@ -212,9 +218,9 @@ myChannel.declareQueue("my-queue");
 myChannel.declareExchange("my-exchange");
 ````
 
-If the first declareQueue() call fails in the example above, your ChannelHandler::onError() 
-method will be called after a while to report this failure. And although the 
-second instruction to declare an exchange has already been sent to the server, it will be 
+If the first declareQueue() call fails in the example above, your Deferred::onError()
+method will be called after a while to report this failure. And although the
+second instruction to declare an exchange has already been sent to the server, it will be
 ignored because the channel was already in an invalid state after the first failure.
 
 You can overcome this by using multiple channels:
@@ -223,7 +229,7 @@ You can overcome this by using multiple channels:
 Channel channel1(connection, &myHandler);
 Channel channel2(connection, &myHandler);
 channel1.declareQueue("my-queue");
-channel2.declareQueue("my-exchange");
+channel2.declareExchange("my-exchange");
 ````
 
 Now, if an error occurs with declaring the queue, it will not have
@@ -233,51 +239,6 @@ RabbitMQ server, so some extra bytes are sent over the network,
 and some additional resources in both the client application and the
 RabbitMQ server are used (although this is all very limited).
 
-Let's get back to the ChannelHandler class. It has many methods that you can 
-implement - all of which are optional. All methods in it have a default empty implementation,
-so you can choose to only override the ones that you are interested in. When you're 
-writing a consumer application for example, you probably are only interested in 
-errors that occur, and in incoming messages:
-
-````c++
-#include <amqpcpp.h>
-
-class MyChannelHandler : public AMQP::ChannelHandler
-{
-public:
-    /**
-     *  Method that is called when an error occurs on the channel, and
-     *  the channel ends up in an error state
-     *  @param  channel     the channel on which the error occured
-     *  @param  message     human readable error message
-     */
-    virtual void onError(AMQP::Channel *channel, const std::string &message)
-    {
-        // @todo
-        //  do something with the error message (like reporting it to the end-user)
-        //  and destruct the channel object because it now no longer is usable
-    }
-
-    /**
-     *  Method that is called when a message has been received on a channel
-     *  This message will be called for every message that is received after
-     *  you started consuming. Make sure you acknowledge the messages when its
-     *  safe to remove them from RabbitMQ (unless you set no-ack option when you
-     *  started the consumer)
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  message         the consumed message
-     *  @param  deliveryTag     the delivery tag, you need this to acknowledge the message
-     *  @param  consumerTag     the consumer identifier that was used to retrieve this message
-     *  @param  redelivered     is this a redelivered message?
-     */
-    virtual void onReceived(AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) 
-    {
-        // @todo
-        //  do something with the incoming message
-    }
-};
-````
-
 FLAGS AND TABLES
 ================
 
@@ -290,30 +251,30 @@ tables are used by many methods.
 ````c++
 /**
  *  Declare a queue
- * 
+ *
  *  If you do not supply a name, a name will be assigned by the server.
- * 
+ *
  *  The flags can be a combination of the following values:
- * 
+ *
  *      -   durable     queue survives a broker restart
  *      -   autodelete  queue is automatically removed when all connected consumers are gone
  *      -   passive     only check if the queue exist
  *      -   exclusive   the queue only exists for this connection, and is automatically removed when connection is gone
- *    
+ *
  *  @param  name        name of the queue
  *  @param  flags       combination of flags
  *  @param  arguments   optional arguments
  */
-bool declareQueue(const std::string &name, int flags, const AMQP::Table &arguments);
-bool declareQueue(const std::string &name, const AMQP::Table &arguments);
-bool declareQueue(const std::string &name, int flags = 0);
-bool declareQueue(int flags, const AMQP::Table &arguments);
-bool declareQueue(const AMQP::Table &arguments);
-bool declareQueue(int flags = 0);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, const Table &arguments);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags = 0);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags, const Table &arguments);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const Table &arguments);
+Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags = 0);
 ````
 
 As you can see, the method comes in many forms, and it is up to you to choose
-the one that is most appropriate. We now take a look at the most complete 
+the one that is most appropriate. We now take a look at the most complete
 one, the method with three parameters.
 
 Many methods in the Channel class accept an integer parameter named 'flags'.
@@ -324,13 +285,13 @@ AMQP::durable + AMQP::autodelete.
 
 The declareQueue() method also accepts a parameter named 'arguments', which is of type
 Table. This Table object can be used as an associative array to send additional
-options to RabbitMQ, that are often custom RabbitMQ extensions to the AMQP 
+options to RabbitMQ, that are often custom RabbitMQ extensions to the AMQP
 standard. For a list of all supported arguments, take a look at the documentation
 on the RabbitMQ website. With every new RabbitMQ release more features, and
 supported arguments are added.
 
-The Table class is a very powerful class that enables you to build 
-complicated, deeply nested structures full of strings, arrays and even other 
+The Table class is a very powerful class that enables you to build
+complicated, deeply nested structures full of strings, arrays and even other
 tables. In reality, you only need strings and integers.
 
 ````c++
@@ -354,13 +315,13 @@ you're publishing - all these parameters are standard C++ strings.
 
 More extended versions of the publish() method exist that accept additional
 arguments, and that enable you to publish entire Envelope objects, which are
-objects that contain the message plus a list of optional meta information like 
-the content-type, content-encoding, priority, expire time and more. None of these 
-meta fields are interpreted by this library, and also the RabbitMQ ignores most 
-of them, but the AMQP protocol defines them, and they are free for you to use. 
-For an extensive list of the fields that are supported, take a look at the MetaData.h 
-header file (MetaData is the base class for Envelope). You should also check the 
-RabbitMQ documentation to find out if an envelope header is interpreted by the 
+objects that contain the message plus a list of optional meta information like
+the content-type, content-encoding, priority, expire time and more. None of these
+meta fields are interpreted by this library, and also the RabbitMQ ignores most
+of them, but the AMQP protocol defines them, and they are free for you to use.
+For an extensive list of the fields that are supported, take a look at the MetaData.h
+header file (MetaData is the base class for Envelope). You should also check the
+RabbitMQ documentation to find out if an envelope header is interpreted by the
 RabbitMQ server (at the time of this writing, only the expire time is being used).
 
 The following snippet is copied from the Channel.h header file and lists all
@@ -370,17 +331,17 @@ in almost any form:
 ````c++
 /**
  *  Publish a message to an exchange
- * 
+ *
  *  The following flags can be used
- * 
+ *
  *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
  *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
- * 
+ *
  *  If either of the two flags is set, and the message could not immediately
  *  be published, the message is returned by the server to the client. If you
- *  want to catch such returned messages, you need to implement the 
+ *  want to catch such returned messages, you need to implement the
  *  ChannelHandler::onReturned() method.
- * 
+ *
  *  @param  exchange    the exchange to publish to
  *  @param  routingkey  the routing key
  *  @param  flags       optional flags (see above)
@@ -396,18 +357,29 @@ bool publish(const std::string &exchange, const std::string &routingKey, int fla
 bool publish(const std::string &exchange, const std::string &routingKey, const char *message, size_t size);
 ````
 
-Published messages are normally not confirmed by the server, hence there is no
-ChannelHandler::onPublished() method that you can implement to find out if
-a message was correctly received by the server. That's by design in the
-AMQP protocol, to not unnecessarily slow down message publishing. As long 
-as no error is reported via the ChannelHandler::onError() method, you can safely 
+Published messages are normally not confirmed by the server, therefore the publish method does not
+return a deferred. That's by design in the AMQP protocol, to not unnecessarily slow down message
+publishing. As long as no error is reported via the ChannelHandler::onError() method, you can safely
 assume that your messages were delivered.
 
-If you use the flags parameter to set either the option 'mandatory' or 
-'immediate', a message that could not be routed or directly delivered to a consumer 
-is sent back to the client, and ends up in the ChannelHandler::onReturned() 
-method. At the time of this writing however, the 'immediate' option does not 
-seem to be supported by RabbitMQ.
+This can of course be a problem when you are publishing many messages. If you get an error halfway through
+there is no way to know for sure how many messages made it to the broker and how many should be republished.
+If this is important, you can wrap the publish commands inside a transaction. In this case, if an error occurs,
+the transaction is automatically rolled back by RabbitMQ and none of the messages are actually published.
+
+````c++
+channel.startTransaction();
+channel.publish("my-exchange", "my-key", "my first message");
+channel.publish("my-exchange", "my-key", "another message");
+channel.commitTransaction()
+.onSuccess([](AMQP::Channel *channel) {
+    // all messages were successfully published
+})
+.onError([](AMQP::Channel *channel) {
+    // none of the messages were published
+    // now we have to do it all over again
+});
+````
 
 
 CONSUMING MESSAGES
@@ -430,80 +402,63 @@ The full documentation from the C++ Channel.h headerfile looks like this:
 ````c++
 /**
  *  Tell the RabbitMQ server that we're ready to consume messages
- * 
+ *
  *  After this method is called, RabbitMQ starts delivering messages to the client
  *  application. The consume tag is a string identifier that will be passed to
- *  each received message, so that you can associate incoming messages with a 
+ *  each received message, so that you can associate incoming messages with a
  *  consumer. If you do not specify a consumer tag, the server will assign one
  *  for you.
- * 
+ *
  *  The following flags are supported:
- * 
+ *
  *      -   nolocal             if set, messages published on this channel are not also consumed
  *      -   noack               if set, consumed messages do not have to be acked, this happens automatically
  *      -   exclusive           request exclusive access, only this consumer can access the queue
  *      -   nowait              the server does not have to send a response back that consuming is active
- * 
- *  The method ChannelHandler::onConsumerStarted() will be called when the 
+ *
+ *  The method ChannelHandler::onConsumerStarted() will be called when the
  *  consumer has started (unless the nowait option was set, in which case
  *  no confirmation method is called)
- * 
+ *
  *  @param  queue               the queue from which you want to consume
  *  @param  tag                 a consumer tag that will be associated with this consume operation
  *  @param  flags               additional flags
  *  @param  arguments           additional arguments
  *  @return bool
  */
-bool consume(const std::string &queue, const std::string &tag, int flags, const AMQP::Table &arguments);
-bool consume(const std::string &queue, const std::string &tag, int flags = 0);
-bool consume(const std::string &queue, const std::string &tag, const AMQP::Table &arguments);
-bool consume(const std::string &queue, int flags, const AMQP::Table &arguments);
-bool consume(const std::string &queue, int flags = 0);
-bool consume(const std::string &queue, const AMQP::Table &arguments);
+DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags, const AMQP::Table &arguments);
+DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags = 0);
+DeferredConsumer& consume(const std::string &queue, const std::string &tag, const AMQP::Table &arguments);
+DeferredConsumer& consume(const std::string &queue, int flags, const AMQP::Table &arguments);
+DeferredConsumer& consume(const std::string &queue, int flags = 0);
+DeferredConsumer& consume(const std::string &queue, const AMQP::Table &arguments);
 ````
 
-In your ChannelHandler you can override the onConsumerStarted() method, that will be
-first called before any messages are sent to you. Most users choose not to override this
-method, because there is not much useful to do in it. After the consumer has started, however,
-messages are starting to be sent from RabbitMQ to your client application, and they are all
-passed to the ChannelHandler::onReceived() method. This method is thus very important to implement.
+As you can see, the consume method returns a DeferredConsumer. This object is a regular Deferred, with the
+addition of the onReceived method. This method can be used to retrieve incoming messages after consumption
+has begun.
+
 
 ````c++
-class MyChannelHandler : public AMQP::ChannelHandler
-{
-    /**
-     *  Method that is called when a message has been received on a channel
-     *  This message will be called for every message that is received after
-     *  you started consuming. Make sure you acknowledge the messages when its
-     *  safe to remove them from RabbitMQ (unless you set no-ack option when you
-     *  started the consumer)
-     *  @param  channel         the channel on which the consumer was started
-     *  @param  message         the consumed message
-     *  @param  deliveryTag     the delivery tag, you need this to acknowledge the message
-     *  @param  consumerTag     the consumer identifier that was used to retrieve this message
-     *  @param  redelivered     is this a redelivered message?
-     */
-    virtual void onReceived(AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) 
-    {
-        // @todo
-        //  add your own processing
-        
-        
-        // after the message was processed, acknowledge it
-        channel->ack(deliveryTag);
-    }
-}
+channel.consume("my-queue").onReceived([](AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {
+    // @todo
+    //  add your own processing
+
+
+    // after the message was processed, acknowledge it
+    channel->ack(deliveryTag);
+});
 ````
 
-The Message object holds all information of the delivered message: the actual content, 
+The Message object holds all information of the delivered message: the actual content,
 all meta information from the envelope (in fact, the Message class is derived from the Envelope class),
 and even the name of the exchange and the routing key that were used when the message was originally
 published. For a full list of all information in the Message class, you best have a look at the
 message.h, envelope.h and metadata.h header files.
 
-Another important parameter to the onReceived() method is the deliveryTag parameter. This is a 
+Another important parameter to the onReceived() method is the deliveryTag parameter. This is a
 unique identifier that you need to acknowledge an incoming message. RabbitMQ only removes the
-message after it has been acknowledged, so that if your application crashes while it was busy 
+message after it has been acknowledged, so that if your application crashes while it was busy
 processing the message, the message does not get lost but remains in the queue. But this means that
 after you've processed the message, you must inform RabbitMQ about it by calling the Channel:ack()
 method. This method is very simple and takes in its simplest form only one parameter: the
@@ -518,10 +473,10 @@ or the entire TCP connection, consuming also stops.
 
 RabbitMQ throttles the number of messages that are delivered to you, to prevent that your application
 is flooded with messages from the queue, and to spread out the messages over multiple consumers.
-This is done with a setting called quality-of-service (QOS). The QOS setting is a numeric value which 
-holds the number of unacknowledged messages that you are allowed to have. RabbitMQ stops sending 
-additional messages when the number of unacknowledges messages has reached this limit, and only 
-sends additional messages when an earlier message gets acknowledged. To change the QOS, you can 
+This is done with a setting called quality-of-service (QOS). The QOS setting is a numeric value which
+holds the number of unacknowledged messages that you are allowed to have. RabbitMQ stops sending
+additional messages when the number of unacknowledges messages has reached this limit, and only
+sends additional messages when an earlier message gets acknowledged. To change the QOS, you can
 simple call Channel::setQos().
 
 
@@ -534,11 +489,12 @@ need additional attention:
     -   ability to set up secure connections (or is this fully done on the IO level)
     -   login with other protocols than login/password
     -   publish confirms
+    -   returned messages
 
-We also need to add more safety checks so that strange or invalid data from 
-RabbitMQ does not break the library (although in reality RabbitMQ only sends 
+We also need to add more safety checks so that strange or invalid data from
+RabbitMQ does not break the library (although in reality RabbitMQ only sends
 valid data). Also, when we now receive an answer from RabbitMQ that does not
-match the request that we sent before, we do not report an error (this is also 
+match the request that we sent before, we do not report an error (this is also
 an issue that only occurs in theory).
 
 It would be nice to have sample implementations for the ConnectionHandler

From 3680d621baf57dbee2109789a2ef65c32af6fd5b Mon Sep 17 00:00:00 2001
From: Luca Marturana <lucamarturana@gmail.com>
Date: Fri, 11 Apr 2014 11:18:59 +0200
Subject: [PATCH 10/41] Bug fix on array serialization

---
 src/array.cpp | 14 ++++++++------
 src/table.cpp |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/array.cpp b/src/array.cpp
index 706572d..ca1d4cb 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -95,11 +95,11 @@ size_t Array::size() const
     size_t size = 4;
 
     // iterate over all elements
-    for (auto iter(_fields.begin()); iter != _fields.end(); ++iter)
+    for (auto item : _fields)
     {
         // add the size of the field type and size of element
-        size += sizeof((*iter)->typeID());
-        size += (*iter)->size();
+        size += sizeof(item->typeID());
+        size += item->size();
     }
 
     // return the result
@@ -111,12 +111,14 @@ size_t Array::size() const
  */
 void Array::fill(OutBuffer& buffer) const
 {
+    buffer.add(static_cast<uint32_t>(size()-4));
+
     // iterate over all elements
-    for (auto iter(_fields.begin()); iter != _fields.end(); ++iter)
+    for (auto item : _fields)
     {
         // encode the element type and element
-        buffer.add((*iter)->typeID());
-        (*iter)->fill(buffer);
+        buffer.add((uint8_t)item->typeID());
+        item->fill(buffer);
     }
 }
 
diff --git a/src/table.cpp b/src/table.cpp
index 4be9b11..d0fb853 100644
--- a/src/table.cpp
+++ b/src/table.cpp
@@ -145,7 +145,7 @@ size_t Table::size() const
 void Table::fill(OutBuffer& buffer) const
 {
     // add size
-    buffer.add((uint32_t) size()-4);
+    buffer.add(static_cast<uint32_t>(size()-4));
 
     // loop through the fields
     for (auto iter(_fields.begin()); iter != _fields.end(); ++iter)

From cf5def0e89fa41460614479f8ee0d47ff9db07b2 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Mon, 14 Apr 2014 13:34:46 +0200
Subject: [PATCH 11/41] fixed operator[] for arrays and strings, implemented <<
 operator for field and fieldproxy objects to simplify debugging (reported
 from issue #7)

---
 amqpcpp.h              |   1 +
 include/array.h        |  51 +++++++++++++--
 include/booleanset.h   |  16 +++++
 include/decimalfield.h |  10 +++
 include/field.h        |  18 +++++-
 include/fieldproxy.h   | 141 ++++++++++++-----------------------------
 include/numericfield.h |  10 +++
 include/stringfield.h  |  10 +++
 include/table.h        |  29 +++++++++
 src/Makefile           |   2 +-
 src/array.cpp          |  14 ++++
 src/includes.h         |   3 +
 12 files changed, 197 insertions(+), 108 deletions(-)

diff --git a/amqpcpp.h b/amqpcpp.h
index 3ae5c67..8f905c1 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -17,6 +17,7 @@
 #include <cstddef>
 #include <cstring>
 #include <stdexcept>
+#include <iostream>
 
 // base C include files
 #include <stdint.h>
diff --git a/include/array.h b/include/array.h
index 7e59406..ca165c2 100644
--- a/include/array.h
+++ b/include/array.h
@@ -83,8 +83,20 @@ public:
      */
     Array set(uint8_t index, const Field &value)
     {
-        // copy to a new pointer and store it
-        _fields[index] = std::shared_ptr<Field>(value.clone());
+        // construct a shared pointer
+        auto ptr = std::shared_ptr<Field>(value.clone());
+        
+        // should we overwrite an existing record?
+        if (index <= _fields.size())
+        {
+            // append index
+            _fields.push_back(ptr);
+        }
+        else
+        {
+            // overwrite pointer
+            _fields[index] = ptr;
+        }
 
         // allow chaining
         return *this;
@@ -108,14 +120,14 @@ public:
     uint32_t count() const;
 
     /**
-     * Remove last element from array
+     *  Remove last element from array
      */
     void pop_back();
 
     /**
-     * Add field to end of array
+     *  Add field to end of array
      *
-     * @param value
+     *  @param value
      */
     void push_back(const Field &value);
 
@@ -145,6 +157,35 @@ public:
     {
         return 'A';
     }
+
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const
+    {
+        // prefix
+        stream << "array(";
+        
+        // is this the first iteration
+        bool first = true;
+        
+        // loop through all members
+        for (auto iter : _fields) 
+        {
+            // split with comma
+            if (!first) stream << ",";
+            
+            // show output
+            stream << *iter;
+            
+            // no longer first iter
+            first = false;
+        }
+        
+        // postfix
+        stream << ")";
+    }
 };
 
 /**
diff --git a/include/booleanset.h b/include/booleanset.h
index 577fe47..f165643 100644
--- a/include/booleanset.h
+++ b/include/booleanset.h
@@ -83,6 +83,22 @@ public:
         return new BooleanSet(*this);
     }
 
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const override
+    {
+        // prefix
+        stream << "booleanset(";
+        
+        // the members
+        for (int i=0; i<8; i++) stream << (i == 0 ? "" : ",") << (get(i) ? 1 : 0);
+        
+        // postfix
+        stream << ")";
+    }
+
     /**
      *  Get one of the booleans
      *  @param  index   from 0 to 7, where 0 is rightmost bit
diff --git a/include/decimalfield.h b/include/decimalfield.h
index c9d3cfc..3164286 100644
--- a/include/decimalfield.h
+++ b/include/decimalfield.h
@@ -88,6 +88,16 @@ public:
         return new DecimalField(_places, _number);
     }
 
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const override
+    {
+        // output floating point value
+        stream << "decimal(" << _number / pow(10, _places) << ")";
+    }
+
     /**
      *  Assign a new value
      *
diff --git a/include/field.h b/include/field.h
index 079c741..76f89ba 100644
--- a/include/field.h
+++ b/include/field.h
@@ -59,9 +59,25 @@ public:
      */
     virtual char typeID() const = 0;
     
-    
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const = 0;
 };
 
+/**
+ *  Custom output stream operator
+ *  @param  stream
+ *  @param  field
+ *  @return ostream
+ */
+inline std::ostream &operator<<(std::ostream &stream, const Field &field)
+{
+    field.output(stream);
+    return stream;
+}
+
 /**
  *  end namespace
  */
diff --git a/include/fieldproxy.h b/include/fieldproxy.h
index ad8c445..5cafcdc 100644
--- a/include/fieldproxy.h
+++ b/include/fieldproxy.h
@@ -196,21 +196,14 @@ public:
         // cast to a string
         return operator=(std::string(value));
     }
-
+    
     /**
-     *  Get boolean value
-     *  @return BooleanSet
+     *  Get the underlying field
+     *  @return Field
      */
-    operator BooleanSet ()
+    const Field &get() const
     {
-        // the value
-        BooleanSet value;
-
-        // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value;
+        return _source->get(_index);
     }
 
     /**
@@ -219,14 +212,8 @@ public:
      */
     operator bool ()
     {
-        // the value
-        BooleanSet value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -235,14 +222,8 @@ public:
      */
     operator int8_t ()
     {
-        // the value
-        Octet value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -251,14 +232,8 @@ public:
      */
     operator uint8_t ()
     {
-        // the value
-        UOctet value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -267,14 +242,8 @@ public:
      */
     operator int16_t ()
     {
-        // the value
-        Short value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -283,14 +252,8 @@ public:
      */
     operator uint16_t ()
     {
-        // the value
-        UShort value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -299,14 +262,8 @@ public:
      */
     operator int32_t ()
     {
-        // the value
-        Long value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -315,14 +272,8 @@ public:
      */
     operator uint32_t ()
     {
-        // the value
-        ULong value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -331,14 +282,8 @@ public:
      */
     operator int64_t ()
     {
-        // the value
-        Long value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -347,30 +292,8 @@ public:
      */
     operator uint64_t ()
     {
-        // the value
-        ULong value;
-
         // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
-    }
-
-    /**
-     *  Get decimal value
-     *  @return DecimalField
-     */
-    operator DecimalField ()
-    {
-        // the value
-        DecimalField value;
-
-        // retrieve the value
-        _source->get(_index, value);
-
-        // return the result
-        return value.value();
+        return _source->get(_index);
     }
 
     /**
@@ -379,16 +302,8 @@ public:
      */
     operator std::string ()
     {
-        // it has to be either a short or a long string
-        ShortString shortValue;
-        LongString longValue;
-
-        // try to retrieve the value
-        if (_source->get(_index, shortValue)) return shortValue.value();
-        if (_source->get(_index, longValue))  return longValue.value();
-
-        // no valid string found
-        return std::string("");
+        // retrieve the value
+        return _source->get(_index);
     }
 };
 
@@ -396,6 +311,30 @@ public:
 typedef FieldProxy<Table, std::string> AssociativeFieldProxy;
 typedef FieldProxy<Array, uint8_t> ArrayFieldProxy;
 
+/**
+ *  Custom output stream operator
+ *  @param  stream
+ *  @param  field
+ *  @return ostream
+ */
+inline std::ostream &operator<<(std::ostream &stream, const AssociativeFieldProxy &field)
+{
+    // get underlying field, and output that
+    return stream << field.get();
+}
+
+/**
+ *  Custom output stream operator
+ *  @param  stream
+ *  @param  field
+ *  @return ostream
+ */
+inline std::ostream &operator<<(std::ostream &stream, const ArrayFieldProxy &field)
+{
+    // get underlying field, and output that
+    return stream << field.get();
+}
+
 /**
  *  end namespace
  */
diff --git a/include/numericfield.h b/include/numericfield.h
index 82edf99..9a60e4d 100644
--- a/include/numericfield.h
+++ b/include/numericfield.h
@@ -157,6 +157,16 @@ public:
     {
         return F;
     }
+
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const override
+    {
+        // show
+        stream << "numeric(" << value() << ")";
+    }
 };
 
 /**
diff --git a/include/stringfield.h b/include/stringfield.h
index 724b495..3def910 100644
--- a/include/stringfield.h
+++ b/include/stringfield.h
@@ -145,6 +145,16 @@ public:
     {
         return F;
     }
+
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const override
+    {
+        // show
+        stream << "string(" << value() << ")";
+    }
 };
 
 /**
diff --git a/include/table.h b/include/table.h
index 3435f13..f7682e5 100644
--- a/include/table.h
+++ b/include/table.h
@@ -136,6 +136,35 @@ public:
     {
         return 'F';
     }
+
+    /**
+     *  Output the object to a stream
+     *  @param std::ostream
+     */
+    virtual void output(std::ostream &stream) const
+    {
+        // prefix
+        stream << "table(";
+        
+        // is this the first iteration
+        bool first = true;
+        
+        // loop through all members
+        for (auto iter : _fields) 
+        {
+            // split with comma
+            if (!first) stream << ",";
+            
+            // show output
+            stream << iter.first << ":" << *iter.second;
+            
+            // no longer first iter
+            first = false;
+        }
+        
+        // postfix
+        stream << ")";
+    }
 };
 
 /**
diff --git a/src/Makefile b/src/Makefile
index 3a9b4e9..4f0baa2 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,6 +1,6 @@
 CPP			    = g++
 RM			    = rm -f
-CPPFLAGS		= -Wall -c -I. -O2 -flto -std=c++11 -g
+CPPFLAGS		= -Wall -c -I. -g -flto -std=c++11 -g
 LD			    = g++
 LD_FLAGS		= -Wall -shared -O2
 SHARED_LIB		= libamqpcpp.so
diff --git a/src/array.cpp b/src/array.cpp
index ca1d4cb..175c168 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -70,16 +70,27 @@ const Field &Array::get(uint8_t index)
     return *_fields[index];
 }
 
+/**
+ *  Number of entries in the array
+ *  @return uint32_t
+ */
 uint32_t Array::count() const
 {
   return _fields.size();
 }
 
+/**
+ *  Remove a field from the array
+ */
 void Array::pop_back()
 {
     _fields.pop_back();
 }
 
+/**
+ *  Add a field to the array
+ *  @param  value
+ */
 void Array::push_back(const Field& value)
 {
     _fields.push_back(std::shared_ptr<Field>(value.clone()));
@@ -88,6 +99,7 @@ void Array::push_back(const Field& value)
 /**
  *  Get the size this field will take when
  *  encoded in the AMQP wire-frame format
+ *  @return size_t
  */
 size_t Array::size() const
 {
@@ -108,9 +120,11 @@ size_t Array::size() const
 
 /**
  *  Write encoded payload to the given buffer.
+ *  @param  buffer
  */
 void Array::fill(OutBuffer& buffer) const
 {
+    // store total size for all elements
     buffer.add(static_cast<uint32_t>(size()-4));
 
     // iterate over all elements
diff --git a/src/includes.h b/src/includes.h
index 52b31d0..d6c8e0f 100644
--- a/src/includes.h
+++ b/src/includes.h
@@ -7,6 +7,9 @@
  *  @documentation private
  */
 
+// for debug
+#include <iostream>
+
 // include the generic amqp functions
 #include "../amqpcpp.h"
 

From 1c0495378ae2bc7058305ffe24cdac4232aa14c5 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Mon, 14 Apr 2014 14:10:57 +0200
Subject: [PATCH 12/41] Implemented deferred consumers and a setTimeout method
 on the connection handler for indicating immediate failures on deferred
 objects

---
 amqpcpp.h                   |  2 +
 include/connection.h        | 18 ---------
 include/connectionhandler.h | 36 ++++++++++++------
 include/connectionimpl.h    |  2 +-
 include/deferred.h          |  5 +--
 include/deferredconsumer.h  | 76 +++++++++++++++++++++++++++++++++++++
 src/channelimpl.cpp         | 22 ++++++-----
 src/connectionimpl.cpp      | 70 +++++++++++++++++-----------------
 8 files changed, 151 insertions(+), 80 deletions(-)
 create mode 100644 include/deferredconsumer.h

diff --git a/amqpcpp.h b/amqpcpp.h
index 908da12..e2173e8 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -6,6 +6,8 @@
  *  @documentation public
  */
 
+#pragma once
+
 // base C++ include files
 #include <vector>
 #include <string>
diff --git a/include/connection.h b/include/connection.h
index a5fed2b..a67e6ad 100644
--- a/include/connection.h
+++ b/include/connection.h
@@ -22,24 +22,6 @@ private:
      */
     ConnectionImpl _implementation;
 
-    /**
-     *  Function to execute code after a certain timeout.
-     *
-     *  If the timeout is 0, the code is supposed to be run
-     *  in the next iteration of the event loop.
-     *
-     *  This is a simple placeholder function that will just
-     *  execute the code immediately, it should be overridden
-     *  by the timeout function the used event loop has.
-     *
-     *  @param  timeout     the amount of time to wait
-     *  @param  callback    the callback to execute after the timeout
-     */
-    std::function<void(double timeout, const std::function<void()>)> _timeoutHandler = [](double timeout, const std::function<void()>& callback) {
-        // execute callback immediately
-        callback();
-    };
-
 public:
     /**
      *  Construct an AMQP object based on full login data
diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 7a90b50..f5c1d0c 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -4,7 +4,7 @@
  *
  *  Interface that should be implemented by the caller of the library and
  *  that is passed to the AMQP connection. This interface contains all sorts
- *  of methods that are called when data needs to be sent, or when the 
+ *  of methods that are called when data needs to be sent, or when the
  *  AMQP connection ends up in a broken state.
  *
  *  @copyright 2014 Copernica BV
@@ -21,10 +21,22 @@ namespace AMQP {
 class ConnectionHandler
 {
 public:
+    /**
+     *  Set a function to be executed after a given timeout.
+     *
+     *  This function is not strictly necessary to implement. If you
+     *  do not implement it, certain channel methods that fail
+     *  immediately will not be reported.
+     *
+     *  @param  timeout         number of seconds to wait
+     *  @param  callback        function to execute once time runs out
+     */
+    virtual void setTimeout(double seconds, const std::function<void()>& callback) {}
+
     /**
      *  Method that is called when data needs to be sent over the network
      *
-     *  Note that the AMQP library does no buffering by itself. This means 
+     *  Note that the AMQP library does no buffering by itself. This means
      *  that this method should always send out all data or do the buffering
      *  itself.
      *
@@ -33,28 +45,28 @@ public:
      *  @param  size            Size of the buffer
      */
     virtual void onData(Connection *connection, const char *buffer, size_t size) = 0;
-    
+
     /**
      *  When the connection ends up in an error state this method is called.
      *  This happens when data comes in that does not match the AMQP protocol
-     *  
+     *
      *  After this method is called, the connection no longer is in a valid
      *  state and can no longer be used.
-     * 
+     *
      *  This method has an empty default implementation, although you are very
      *  much advised to implement it. Because when an error occurs, the connection
      *  is no longer usable, so you probably want to know.
-     * 
+     *
      *  @param  connection      The connection that entered the error state
      *  @param  message         Error message
      */
     virtual void onError(Connection *connection, const std::string &message) {}
-    
+
     /**
      *  Method that is called when the login attempt succeeded. After this method
      *  was called, the connection is ready to use. This is the first method
      *  that is normally called after you've constructed the connection object.
-     * 
+     *
      *  According to the AMQP protocol, you must wait for the connection to become
      *  ready (and this onConnected method to be called) before you can start
      *  using the Connection object. However, this AMQP library will cache all
@@ -64,17 +76,17 @@ public:
      *  @param  connection      The connection that can now be used
      */
     virtual void onConnected(Connection *connection) {}
-    
+
     /**
      *  Method that is called when the connection was closed.
-     * 
+     *
      *  This is the counter part of a call to Connection::close() and it confirms
      *  that the connection was correctly closed.
-     * 
+     *
      *  @param  connection      The connection that was closed and that is now unusable
      */
     virtual void onClosed(Connection *connection) {}
-    
+
 };
 
 /**
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index 26f7f63..bcbeed0 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -298,7 +298,7 @@ public:
      *  The actual connection is a friend and can construct this class
      */
     friend class Connection;
-
+    friend class ChannelImpl;
 };
 
 /**
diff --git a/include/deferred.h b/include/deferred.h
index 489c537..e2fb2d0 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -56,11 +56,8 @@ private:
      *
      *  @param  error   description of the error that occured
      */
-    void error(const std::string& error)
+    void error(const std::string& error) const
     {
-        // we are now in a failed state
-        _failed = true;
-
         // execute callbacks if registered
         if (_errorCallback)     _errorCallback(_channel, error);
         if (_finalizeCallback)  _finalizeCallback(_channel, error);
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
new file mode 100644
index 0000000..3610bd7
--- /dev/null
+++ b/include/deferredconsumer.h
@@ -0,0 +1,76 @@
+/**
+ *  DeferredConsumer.h
+ *
+ *  Deferred callback for consumers
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  We extend from the default deferred and add extra functionality
+ */
+class DeferredConsumer : public Deferred<const std::string&>
+{
+private:
+    /**
+     *  Callback to execute when a message arrives
+     */
+    std::function<void(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)> _messageCallback;
+
+    /**
+     *  Process a message
+     *
+     *  @param  message the message to process
+     *  @param  deliveryTag the message delivery tag
+     *  @param  consumerTag the tag we are consuming under
+     *  @param  is this a redelivered message?
+     */
+    void message(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) const
+    {
+        // do we have a valid callback
+        if (_messageCallback) _messageCallback(_channel, message, deliveryTag, consumerTag, redelivered);
+    }
+
+    /**
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+    friend class ConsumedMessage;
+protected:
+    /**
+     *  Protected constructor that can only be called
+     *  from within the channel implementation
+     *
+     *  @param  channel the channel we operate under
+     *  @param  boolea  are we already failed?
+     */
+    DeferredConsumer(Channel *channel, bool failed = false) :
+        Deferred(channel, failed)
+    {}
+public:
+    /**
+     *  Register a function to be called when a message arrives
+     *
+     *  Only one callback can be registered. Successive calls
+     *  to this function will clear callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    DeferredConsumer& onReceived(const std::function<void(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>& callback)
+    {
+        // store callback
+        _messageCallback = callback;
+        return *this;
+    }
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index f65237f..8607026 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -540,25 +540,27 @@ template <typename... Arguments>
 Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *message)
 {
     // create a new deferred handler and get a pointer to it
-    auto &handler = _callbacks.push_back(Deferred<Arguments...>(_parent));
+    // note: cannot use auto here or the lambda below chokes
+    // when compiling under gcc 4.8
+    Deferred<Arguments...> *handler = &_callbacks.push_back(Deferred<Arguments...>(_parent));
 
     // send the frame over the channel
     if (!send(frame))
     {
         // we can immediately put the handler in failed state
-        handler._failed = true;
+        handler->_failed = true;
 
-        // the frame could not be send
-        // we should register an error
-        // on the handler, but only after
-        // a timeout, so a handler can
-        // be attached first
-
-        // TODO
+        // register an error on the deferred handler
+        // after a timeout, so it gets called only
+        // after a possible handler was installed.
+        _connection->_handler->setTimeout(0, [handler, message]() {
+            // emit an error on the handler
+            handler->error(message);
+        });
     }
 
     // return the new handler
-    return handler;
+    return *handler;
 }
 
 /**
diff --git a/src/connectionimpl.cpp b/src/connectionimpl.cpp
index 8f40fde..668fbb3 100644
--- a/src/connectionimpl.cpp
+++ b/src/connectionimpl.cpp
@@ -17,13 +17,13 @@ namespace AMQP {
 
 /**
  *  Construct an AMQP object based on full login data
- * 
+ *
  *  The first parameter is a handler object. This handler class is
  *  an interface that should be implemented by the caller.
- * 
+ *
  *  Note that the constructor is private to ensure that nobody can construct
  *  this class, only the real Connection class via a friend construct
- * 
+ *
  *  @param  parent          Parent connection object
  *  @param  handler         Connection handler
  *  @param  login           Login data
@@ -42,7 +42,7 @@ ConnectionImpl::~ConnectionImpl()
 {
     // close the connection in a nice fashion
     close();
-    
+
     // invalidate all channels, so they will no longer call methods on this channel object
     for (auto iter = _channels.begin(); iter != _channels.end(); iter++) iter->second->invalidate();
 }
@@ -57,20 +57,20 @@ uint16_t ConnectionImpl::add(ChannelImpl *channel)
 {
     // check if we have exceeded the limit already
     if (_maxChannels > 0 && _channels.size() >= _maxChannels) return 0;
-    
+
     // keep looping to find an id that is not in use
     while (true)
     {
         // is this id in use?
         if (_nextFreeChannel > 0 && _channels.find(_nextFreeChannel) == _channels.end()) break;
-        
+
         // id is in use, move on
         _nextFreeChannel++;
     }
-    
+
     // we have a new channel
     _channels[_nextFreeChannel] = channel;
-    
+
     // done
     return _nextFreeChannel++;
 }
@@ -90,7 +90,7 @@ void ConnectionImpl::remove(ChannelImpl *channel)
 
 /**
  *  Parse the buffer into a recognized frame
- *  
+ *
  *  Every time that data comes in on the connection, you should call this method to parse
  *  the incoming data, and let it handle by the AMQP library. This method returns the number
  *  of bytes that were processed.
@@ -108,13 +108,13 @@ size_t ConnectionImpl::parse(const char *buffer, size_t size)
 {
     // do not parse if already in an error state
     if (_state == state_closed) return 0;
-    
+
     // number of bytes processed
     size_t processed = 0;
-    
+
     // create a monitor object that checks if the connection still exists
     Monitor monitor(this);
-    
+
     // keep looping until we have processed all bytes, and the monitor still
     // indicates that the connection is in a valid state
     while (size > 0 && monitor.valid())
@@ -131,7 +131,7 @@ size_t ConnectionImpl::parse(const char *buffer, size_t size)
 
             // number of bytes processed
             size_t bytes = receivedFrame.totalSize();
-            
+
             // add bytes
             processed += bytes; size -= bytes; buffer += bytes;
         }
@@ -139,12 +139,12 @@ size_t ConnectionImpl::parse(const char *buffer, size_t size)
         {
             // something terrible happened on the protocol (like data out of range)
             reportError(exception.what());
-            
+
             // done
             return processed;
         }
     }
-    
+
     // done
     return processed;
 }
@@ -161,13 +161,13 @@ bool ConnectionImpl::close()
 
     // mark that the object is closed
     _closed = true;
-    
+
     // if still busy with handshake, we delay closing for a while
     if (_state == state_handshake || _state == state_protocol) return true;
 
     // perform the close operation
     sendClose();
-    
+
     // done
     return true;
 }
@@ -181,26 +181,26 @@ bool ConnectionImpl::sendClose()
 {
     // after the send operation the object could be dead
     Monitor monitor(this);
-    
+
     // loop over all channels
     for (auto iter = _channels.begin(); iter != _channels.end(); iter++)
     {
         // close the channel
         iter->second->close();
-        
+
         // we could be dead now
         if (!monitor.valid()) return false;
     }
-    
+
     // send the close frame
     send(ConnectionCloseFrame(0, "shutdown"));
-    
+
     // leap out if object no longer is alive
     if (!monitor.valid()) return false;
-    
+
     // we're in a new state
     _state = state_closing;
-    
+
     // done
     return true;
 }
@@ -214,20 +214,20 @@ void ConnectionImpl::setConnected()
     _state = state_connected;
 
     // if the close operation was already called, we do that again now again
-    // so that the actual messages to close down the connection and the channel 
+    // so that the actual messages to close down the connection and the channel
     // are appended to the queue
     if (_closed && !sendClose()) return;
-    
+
     // we're going to call the handler, which can destruct the connection,
     // so we must monitor if the queue object is still valid after calling
     Monitor monitor(this);
-    
+
     // inform handler
     _handler->onConnected(_parent);
-    
+
     // leap out if the connection no longer exists
     if (!monitor.valid()) return;
-    
+
     // empty the queue of messages
     while (!_queue.empty())
     {
@@ -236,10 +236,10 @@ void ConnectionImpl::setConnected()
 
         // remove it from the queue
         _queue.pop();
-        
+
         // send it
         _handler->onData(_parent, buffer.data(), buffer.size());
-        
+
         // leap out if the connection was destructed
         if (!monitor.valid()) return;
     }
@@ -254,16 +254,16 @@ bool ConnectionImpl::send(const Frame &frame)
 {
     // its not possible to send anything if closed or closing down
     if (_state == state_closing || _state == state_closed) return false;
-    
+
     // we need an output buffer
     OutBuffer buffer(frame.totalSize());
-    
+
     // fill the buffer
     frame.fill(buffer);
-    
+
     // append an end of frame byte (but not when still negotiating the protocol)
     if (frame.needsSeparator()) buffer.add((uint8_t)206);
-    
+
     // are we still setting up the connection?
     if ((_state == state_connected && _queue.size() == 0) || frame.partOfHandshake())
     {
@@ -275,7 +275,7 @@ bool ConnectionImpl::send(const Frame &frame)
         // the connection is still being set up, so we need to delay the message sending
         _queue.push(std::move(buffer));
     }
-    
+
     // done
     return true;
 }

From f10e33c7c7f14d5d2a5b618b839284cbf1fc6271 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Mon, 14 Apr 2014 14:18:51 +0200
Subject: [PATCH 13/41] Fix logic error in the array type

---
 include/array.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/array.h b/include/array.h
index ca165c2..4eb5c30 100644
--- a/include/array.h
+++ b/include/array.h
@@ -85,9 +85,9 @@ public:
     {
         // construct a shared pointer
         auto ptr = std::shared_ptr<Field>(value.clone());
-        
+
         // should we overwrite an existing record?
-        if (index <= _fields.size())
+        if (index >= _fields.size())
         {
             // append index
             _fields.push_back(ptr);

From 8b0cc3dcc8880d956bff6beb1c38357d0ea88b50 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Mon, 14 Apr 2014 14:33:00 +0200
Subject: [PATCH 14/41] We need the iostream to be included so fields can be
 shown

---
 amqpcpp.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/amqpcpp.h b/amqpcpp.h
index e2173e8..9f84823 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -20,6 +20,7 @@
 #include <cstring>
 #include <stdexcept>
 #include <utility>
+#include <iostream>
 
 // base C include files
 #include <stdint.h>

From f7838492fb7a763ee606b4930045e4c804d3e94c Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Mon, 14 Apr 2014 15:23:53 +0200
Subject: [PATCH 15/41] Removed tests: they are moved to the REACT-CPP-AMQP
 library

---
 tests/Makefile         |  19 ---
 tests/README.md        |   2 -
 tests/main.cpp         |  55 --------
 tests/myconnection.cpp | 293 -----------------------------------------
 tests/myconnection.h   | 118 -----------------
 5 files changed, 487 deletions(-)
 delete mode 100644 tests/Makefile
 delete mode 100644 tests/README.md
 delete mode 100644 tests/main.cpp
 delete mode 100644 tests/myconnection.cpp
 delete mode 100644 tests/myconnection.h

diff --git a/tests/Makefile b/tests/Makefile
deleted file mode 100644
index f1602b5..0000000
--- a/tests/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-CPP			    = g++
-CPPFLAGS		= -Wall -c -I. -O2 -flto -std=c++11 -g
-LD			    = g++
-LDFLAGS			= -lamqpcpp -lcopernica_event -lcopernica_network -lev
-RESULT			= a.out
-SOURCES			= $(wildcard *.cpp)
-OBJECTS			= $(SOURCES:%.cpp=%.o)
-
-all:	${OBJECTS} ${RESULT}
-
-${RESULT}: ${OBJECTS}
-	${LD} -o $@ ${OBJECTS} ${LDFLAGS}
-
-clean:
-	${RM} *.obj *~* ${OBJECTS} ${RESULT}
-
-${OBJECTS}:
-	${CPP} ${CPPFLAGS} -o $@ ${@:%.o=%.cpp}
-
diff --git a/tests/README.md b/tests/README.md
deleted file mode 100644
index 99ebf42..0000000
--- a/tests/README.md
+++ /dev/null
@@ -1,2 +0,0 @@
-I'm sorry, the test case makes use of the closed source Copernica libraries. Maybe someone
-is willing to provide a test case based on plain system calls?
diff --git a/tests/main.cpp b/tests/main.cpp
deleted file mode 100644
index f0c1b04..0000000
--- a/tests/main.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- *  Main.cpp
- *
- *  Test program
- *
- *  @copyright 2014 Copernica BV
- */
-
-/**
- *  Global libraries that we need
- */
-#include <amqpcpp.h>
-#include <copernica/network.h>
-
-/**
- *  Namespaces to use
- */
-using namespace std;
-using namespace Copernica;
-
-/**
- *  Local libraries
- */
-#include "myconnection.h"
-
-/**
- *  Main procedure
- *  @param  argc
- *  @param  argv
- *  @return int
- */
-int main(int argc, const char *argv[])
-{
-    // need an ip
-    if (argc != 2)
-    {
-        // report error
-        std::cerr << "usage: " << argv[0] << " <ip>" << std::endl;
-
-        // done
-        return -1;
-    }
-    else
-    {
-        // create connection
-        MyConnection connection(argv[1]);
-
-        // start the main event loop
-        Event::MainLoop::instance()->run();
-
-        // done
-        return 0;
-    }
-}
-
diff --git a/tests/myconnection.cpp b/tests/myconnection.cpp
deleted file mode 100644
index 7234ad7..0000000
--- a/tests/myconnection.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- *  MyConnection.cpp
- *
- *  @copyright 2014 Copernica BV
- */
-
-/**
- *  Required external libraries
- */
-#include <amqpcpp.h>
-#include <copernica/network.h>
-
-#include <string>
-
-/**
- *  Namespaces to use
- */
-using namespace std;
-using namespace Copernica;
-
-/**
- *  Required local class definitions
- */
-#include "myconnection.h"
-
-/**
- *  Constructor
- */
-MyConnection::MyConnection(const std::string &ip) :
-    _socket(Event::MainLoop::instance(), this),
-    _connection(nullptr),
-    _channel(nullptr)
-{
-    // start connecting
-    if (_socket.connect(Network::Ipv4Address(ip), 5672)) return;
-
-    // failure
-    onFailure(&_socket);
-}
-
-/**
- *  Method that is called when the connection failed
- *  @param  socket      Pointer to the socket
- */
-void MyConnection::onFailure(Network::TcpSocket *socket)
-{
-    // report error
-    std::cout << "connect failure" << std::endl;
-}
-
-/**
- *  Method that is called when the connection timed out (which also is a failure
- *  @param  socket      Pointer to the socket
- */
-void MyConnection::onTimeout(Network::TcpSocket *socket)
-{
-    // report error
-    std::cout << "connect timeout" << std::endl;
-}
-
-/**
- *  Method that is called when the connection succeeded
- *  @param  socket      Pointer to the socket
- */
-void MyConnection::onConnected(Network::TcpSocket *socket)
-{
-    // report connection
-    std::cout << "connected" << std::endl;
-
-    // we are connected, leap out if there already is a amqp connection
-    if (_connection) return;
-
-    // create amqp connection, and a new channel
-    _connection = std::unique_ptr<AMQP::Connection>(new AMQP::Connection(this, AMQP::Login("guest", "guest"), "/"));
-    _channel = std::unique_ptr<AMQP::Channel>(new AMQP::Channel(_connection.get()));
-
-    // watch for the channel becoming ready
-    _channel->onReady([](AMQP::Channel *channel) {
-        // show that we are ready
-        std::cout << "AMQP channel ready, id: " << (int) channel->id() << std::endl;
-    });
-
-    // and of course for channel errors
-    _channel->onError([this](AMQP::Channel *channel, const std::string& message) {
-        // inform the user of the error
-        std::cerr << "AMQP channel error on channel " << channel->id() << ": " << message << std::endl;
-
-        // delete the channel
-        _channel = nullptr;
-
-        // close the connection
-        _connection->close();
-    });
-
-    // declare a queue and let us know when it succeeds
-    _channel->declareQueue("my_queue").onSuccess([](AMQP::Channel *channel, const std::string &name, uint32_t messageCount, uint32_t consumerCount){
-        // queue was successfully declared
-        std::cout << "AMQP Queue declared with name '" << name << "', " << messageCount << " messages and " << consumerCount << " consumer" << std::endl;
-    });
-
-    // also declare an exchange
-    _channel->declareExchange("my_exchange", AMQP::direct).onSuccess([](AMQP::Channel *channel) {
-        // exchange successfully declared
-        std::cout << "AMQP exchange declared" << std::endl;
-    });
-
-    // bind the queue to the exchange
-    _channel->bindQueue("my_exchange", "my_queue", "key").onSuccess([](AMQP::Channel *channel) {
-        // queue successfully bound to exchange
-        std::cout << "AMQP Queue bound" << std::endl;
-    });
-
-    // set quality of service
-    _channel->setQos(1).onSuccess([](AMQP::Channel *channel) {
-        // quality of service successfully set
-        std::cout << "AMQP Quality of Service set" << std::endl;
-    });
-
-    // publish a message to the exchange
-    if (!_channel->publish("my_exchange", "key", "my_message"))
-    {
-        // we could not publish the message, something is wrong somewhere
-        std::cerr << "Unable to publish message" << std::endl;
-
-        // close the channel
-        _channel->close().onSuccess([this](AMQP::Channel *channel) {
-            // also close the connection
-            _connection->close();
-        });
-    }
-
-    // consume the message we just published
-    _channel->consume("my_queue", "my_consumer", AMQP::exclusive)
-    .onReceived([this](AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {
-        // show the message data
-        std::cout << "AMQP consumed: " << message.message() << std::endl;
-
-        // ack the message
-        _channel->ack(deliveryTag);
-
-        // and stop consuming (there is only one message anyways)
-        _channel->cancel("my_consumer").onSuccess([](AMQP::Channel *channel, const std::string& tag) {
-            // we successfully stopped consuming
-            std::cout << "Stopped consuming under tag " << tag << std::endl;
-        });
-
-        // unbind the queue again
-        _channel->unbindQueue("my_exchange", "my_queue", "key").onSuccess([](AMQP::Channel *channel) {
-            // queueu successfully unbound
-            std::cout << "Queue unbound" << std::endl;
-        });
-
-        // the queue should now be empty, so we can delete it
-        _channel->removeQueue("my_queue").onSuccess([](AMQP::Channel *channel, uint32_t messageCount) {
-            // queue was removed, it should have been empty, so messageCount should be 0
-            if (messageCount) std::cerr << "Removed queue which should have been empty but contained " << messageCount << " messages" << std::endl;
-
-            // no messages is the expected behavior
-            else std::cout << "Queue removed" << std::endl;
-        });
-
-        // also remove the exchange
-        _channel->removeExchange("my_exchange").onSuccess([](AMQP::Channel *channel) {
-            // exchange was successfully removed
-            std::cout << "Removed exchange" << std::endl;
-        });
-
-        // everything done, close the channel
-        _channel->close().onSuccess([this](AMQP::Channel *channel) {
-            // channel was closed
-            std::cout << "Channel closed" << std::endl;
-
-            // close the connection too
-            _connection->close();
-        });
-    })
-    .onSuccess([](AMQP::Channel *channel, const std::string& tag) {
-        // consumer was started
-        std::cout << "Started consuming under tag " << tag << std::endl;
-    });
-}
-
-/**
- *  Method that is called when the socket is closed (as a result of a TcpSocket::close() call)
- *  @param  socket      Pointer to the socket
- */
-void MyConnection::onClosed(Network::TcpSocket *socket)
-{
-    // show
-    std::cout << "myconnection closed" << std::endl;
-
-    // close the channel and connection
-    _channel = nullptr;
-    _connection = nullptr;
-
-    // stop the loop
-    Event::MainLoop::instance()->stop();
-}
-
-/**
- *  Method that is called when the peer closed the connection
- *  @param  socket      Pointer to the socket
- */
-void MyConnection::onLost(Network::TcpSocket *socket)
-{
-    // report error
-    std::cout << "connection lost" << std::endl;
-
-    // close the channel and connection
-    _channel = nullptr;
-    _connection = nullptr;
-
-    // stop the loop
-    Event::MainLoop::instance()->stop();
-}
-
-/**
- *  Method that is called when data is received on the socket
- *  @param  socket      Pointer to the socket
- *  @param  buffer      Pointer to the fill input buffer
- */
-void MyConnection::onData(Network::TcpSocket *socket, Network::Buffer *buffer)
-{
-    // leap out if there is no connection
-    if (!_connection) return;
-
-    // let the data be handled by the connection
-    size_t bytes = _connection->parse(buffer->data(), buffer->size());
-
-    // shrink the buffer
-    buffer->shrink(bytes);
-}
-
-/**
- *  Method that is called when data needs to be sent over the network
- *
- *  Note that the AMQP library does no buffering by itself. This means
- *  that this method should always send out all data or do the buffering
- *  itself.
- *
- *  @param  connection      The connection that created this output
- *  @param  buffer          Data to send
- *  @param  size            Size of the buffer
- */
-void MyConnection::onData(AMQP::Connection *connection, const char *buffer, size_t size)
-{
-    // send to the socket
-    _socket.write(buffer, size);
-}
-
-/**
- *  Method that is called when the connection to AMQP was closed
- *  @param  connection  pointer to connection object
- */
-void MyConnection::onClosed(AMQP::Connection *connection)
-{
-    // report that AMQP connection is closed
-    std::cout << "AMQP connection closed" << std::endl;
-
-    // close the underlying socket
-    _socket.close();
-}
-
-/**
- *  When the connection ends up in an error state this method is called.
- *  This happens when data comes in that does not match the AMQP protocol
- *
- *  After this method is called, the connection no longer is in a valid
- *  state and can be used. In normal circumstances this method is not called.
- *
- *  @param  connection      The connection that entered the error state
- *  @param  message         Error message
- */
-void MyConnection::onError(AMQP::Connection *connection, const std::string &message)
-{
-    // report error
-    std::cout << "AMQP Connection error: " << message << std::endl;
-}
-
-/**
- *  Method that is called when the login attempt succeeded. After this method
- *  was called, the connection is ready to use
- *
- *  @param  connection      The connection that can now be used
- */
-void MyConnection::onConnected(AMQP::Connection *connection)
-{
-    // show
-    std::cout << "AMQP login success" << std::endl;
-
-    // create channel if it does not yet exist
-    if (!_channel) _channel = std::unique_ptr<AMQP::Channel>(new AMQP::Channel(connection));
-}
diff --git a/tests/myconnection.h b/tests/myconnection.h
deleted file mode 100644
index 698428b..0000000
--- a/tests/myconnection.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- *  MyConnection.h
- *
- *  Our own test implementation for a connection handler
- *
- *  @copyright 2014 Copernica BV
- */
-
-/**
- *  Class definition
- */
-class MyConnection :
-    public AMQP::ConnectionHandler,
-    public Network::TcpHandler
-{
-private:
-    /**
-     *  The actual TCP socket that is connected with RabbitMQ
-     *  @var    TcpSocket
-     */
-    Network::TcpSocket _socket;
-
-    /**
-     *  The AMQP connection
-     *  @var    Connection
-     */
-    std::unique_ptr<AMQP::Connection> _connection;
-
-    /**
-     *  The AMQP channel
-     *  @var    Channel
-     */
-    std::unique_ptr<AMQP::Channel> _channel;
-
-    /**
-     *  Method that is called when the connection failed
-     *  @param  socket      Pointer to the socket
-     */
-    virtual void onFailure(Network::TcpSocket *socket) override;
-
-    /**
-     *  Method that is called when the connection timed out (which also is a failure
-     *  @param  socket      Pointer to the socket
-     */
-    virtual void onTimeout(Network::TcpSocket *socket) override;
-
-    /**
-     *  Method that is called when the connection succeeded
-     *  @param  socket      Pointer to the socket
-     */
-    virtual void onConnected(Network::TcpSocket *socket) override;
-
-    /**
-     *  Method that is called when the socket is closed (as a result of a TcpSocket::close() call)
-     *  @param  socket      Pointer to the socket
-     */
-    virtual void onClosed(Network::TcpSocket *socket) override;
-
-    /**
-     *  Method that is called when the peer closed the connection
-     *  @param  socket      Pointer to the socket
-     */
-    virtual void onLost(Network::TcpSocket *socket) override;
-
-    /**
-     *  Method that is called when data is received on the socket
-     *  @param  socket      Pointer to the socket
-     *  @param  buffer      Pointer to the fill input buffer
-     */
-    virtual void onData(Network::TcpSocket *socket, Network::Buffer *buffer) override;
-
-    /**
-     *  Method that is called when data needs to be sent over the network
-     *
-     *  Note that the AMQP library does no buffering by itself. This means
-     *  that this method should always send out all data or do the buffering
-     *  itself.
-     *
-     *  @param  connection      The connection that created this output
-     *  @param  buffer          Data to send
-     *  @param  size            Size of the buffer
-     */
-    virtual void onData(AMQP::Connection *connection, const char *buffer, size_t size) override;
-
-    /**
-     *  Method that is called when the connection to AMQP was closed
-     *  @param  connection  pointer to connection object
-     */
-    virtual void onClosed(AMQP::Connection *connection) override;
-
-    /**
-     *  When the connection ends up in an error state this method is called.
-     *  This happens when data comes in that does not match the AMQP protocol
-     *
-     *  After this method is called, the connection no longer is in a valid
-     *  state and can be used. In normal circumstances this method is not called.
-     *
-     *  @param  connection      The connection that entered the error state
-     *  @param  message         Error message
-     */
-    virtual void onError(AMQP::Connection *connection, const std::string &message) override;
-
-    /**
-     *  Method that is called when the login attempt succeeded. After this method
-     *  was called, the connection is ready to use
-     *
-     *  @param  connection      The connection that can now be used
-     */
-    virtual void onConnected(AMQP::Connection *connection) override;
-
-public:
-    /**
-     *  Constructor
-     *  @param  ip
-     */
-    MyConnection(const std::string &ip);
-};
-

From 83621790f4aab8af5787005385f8f7324c57f1a3 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Mon, 14 Apr 2014 15:31:15 +0200
Subject: [PATCH 16/41] Give the connection object to the timeout as well

---
 include/connectionhandler.h | 3 ++-
 src/channelimpl.cpp         | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 84210f2..2ffe23b 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -28,10 +28,11 @@ public:
      *  do not implement it, certain methods that fail immediately
      *  will not be reported.
      *
+     *  @param  connection      the connection that needs the timeout
      *  @param  timeout         number of seconds to wait
      *  @param  callback        function to execute once time runs out
      */
-    virtual void setTimeout(double seconds, const std::function<void()>& callback) {}
+    virtual void setTimeout(Connection *connection, double seconds, const std::function<void()>& callback) {}
 
     /**
      *  Method that is called when data needs to be sent over the network
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 8607026..4609d0d 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -553,7 +553,7 @@ Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *messag
         // register an error on the deferred handler
         // after a timeout, so it gets called only
         // after a possible handler was installed.
-        _connection->_handler->setTimeout(0, [handler, message]() {
+        _connection->_handler->setTimeout(_connection->_parent, 0, [handler, message]() {
             // emit an error on the handler
             handler->error(message);
         });

From bcc6eaff82162d21e6b7e3b3de11e44cd5bc7680 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Mon, 14 Apr 2014 16:04:49 +0200
Subject: [PATCH 17/41] added const access for operator[] (issue #7)

---
 include/array.h | 12 +++++++++++-
 include/table.h | 10 ++++++++++
 src/array.cpp   |  2 +-
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/include/array.h b/include/array.h
index 4eb5c30..ddc07b7 100644
--- a/include/array.h
+++ b/include/array.h
@@ -110,7 +110,7 @@ public:
      *  @param  index   field index
      *  @return Field
      */
-    const Field &get(uint8_t index);
+    const Field &get(uint8_t index) const;
 
     /**
      *  Get number of elements on this array
@@ -141,6 +141,16 @@ public:
     {
         return ArrayFieldProxy(this, index);
     }
+    
+    /**
+     *  Get a const field
+     *  @param  index   field index
+     *  @return Field
+     */
+    const Field &operator[](uint8_t index) const
+    {
+        return get(index);
+    }
 
     /**
      *  Write encoded payload to the given buffer.
diff --git a/include/table.h b/include/table.h
index f7682e5..997c210 100644
--- a/include/table.h
+++ b/include/table.h
@@ -122,6 +122,16 @@ public:
         return AssociativeFieldProxy(this, name);
     }
 
+    /**
+     *  Get a const field
+     *
+     *  @param  name    field name
+     */
+    const Field &operator[](const std::string& name) const
+    {
+        return get(name);
+    }
+
     /**
      *  Write encoded payload to the given buffer. 
      *  @param  buffer
diff --git a/src/array.cpp b/src/array.cpp
index 175c168..d04c865 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -58,7 +58,7 @@ Array::Array(const Array &array)
  *  @param  index   field index
  *  @return Field
  */
-const Field &Array::get(uint8_t index)
+const Field &Array::get(uint8_t index) const
 {
     // used if index does not exist
     static ShortString empty;

From b8d458156986bf616e23c7ebd760a54a6265e81c Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Mon, 14 Apr 2014 17:14:36 +0200
Subject: [PATCH 18/41] cast to array and cast to object implemented,
 refactored shared-ptr and clone() methods to utilize std::make_shared (see
 issue #7)

---
 include/array.h        |  18 +++++--
 include/booleanset.h   |   4 +-
 include/decimalfield.h |   4 +-
 include/field.h        |  21 +++++++-
 include/fieldproxy.h   | 117 +++++++++--------------------------------
 include/numericfield.h |   6 +--
 include/stringfield.h  |   6 +--
 include/table.h        |  39 ++++++++++++--
 src/field.cpp          |  39 ++++++++++++++
 9 files changed, 144 insertions(+), 110 deletions(-)

diff --git a/include/array.h b/include/array.h
index ddc07b7..054fac6 100644
--- a/include/array.h
+++ b/include/array.h
@@ -62,9 +62,9 @@ public:
      *  Create a new instance of this object
      *  @return Field*
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
-        return new Array(*this);
+        return std::make_shared<Array>(*this);
     }
 
     /**
@@ -84,7 +84,7 @@ public:
     Array set(uint8_t index, const Field &value)
     {
         // construct a shared pointer
-        auto ptr = std::shared_ptr<Field>(value.clone());
+        auto ptr = value.clone();
 
         // should we overwrite an existing record?
         if (index >= _fields.size())
@@ -181,7 +181,7 @@ public:
         bool first = true;
         
         // loop through all members
-        for (auto iter : _fields) 
+        for (auto &iter : _fields) 
         {
             // split with comma
             if (!first) stream << ",";
@@ -196,6 +196,16 @@ public:
         // postfix
         stream << ")";
     }
+    
+    /**
+     *  Cast to array
+     *  @return Array
+     */
+    virtual operator const Array& () const override
+    {
+        // this already is an array, so no cast is necessary
+        return *this;
+    }
 };
 
 /**
diff --git a/include/booleanset.h b/include/booleanset.h
index f165643..b527048 100644
--- a/include/booleanset.h
+++ b/include/booleanset.h
@@ -78,9 +78,9 @@ public:
      *  Extending from field forces us to implement a clone function.
      *  @return shared_ptr
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
-        return new BooleanSet(*this);
+        return std::make_shared<BooleanSet>(*this);
     }
 
     /**
diff --git a/include/decimalfield.h b/include/decimalfield.h
index 3164286..75a8ab0 100644
--- a/include/decimalfield.h
+++ b/include/decimalfield.h
@@ -83,9 +83,9 @@ public:
      *  Create a new identical instance of this object
      *  @return Field*
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
-        return new DecimalField(_places, _number);
+        return std::make_shared<DecimalField>(_places, _number);
     }
 
     /**
diff --git a/include/field.h b/include/field.h
index 76f89ba..d6a7a88 100644
--- a/include/field.h
+++ b/include/field.h
@@ -37,7 +37,7 @@ public:
      *  Create a new instance on the heap of this object, identical to the object passed
      *  @return Field*
      */
-    virtual Field *clone() const = 0;
+    virtual std::shared_ptr<Field> clone() const = 0;
 
     /**
      *  Get the size this field will take when
@@ -64,6 +64,25 @@ public:
      *  @param std::ostream
      */
     virtual void output(std::ostream &stream) const = 0;
+    
+    /**
+     *  Casting operators
+     *  @return mixed
+     */
+    virtual operator const std::string& () const;
+    virtual operator const char * () const { return nullptr; }
+    virtual operator uint8_t () const { return 0; }
+    virtual operator uint16_t () const { return 0; }
+    virtual operator uint32_t () const { return 0; }
+    virtual operator uint64_t () const { return 0; }
+    virtual operator int8_t () const { return 0; }
+    virtual operator int16_t () const { return 0; }
+    virtual operator int32_t () const { return 0; }
+    virtual operator int64_t () const { return 0; }
+    virtual operator float () const { return 0; }
+    virtual operator double () const { return 0; }
+    virtual operator const Array& () const;
+    virtual operator const Table& () const;
 };
 
 /**
diff --git a/include/fieldproxy.h b/include/fieldproxy.h
index 5cafcdc..2666850 100644
--- a/include/fieldproxy.h
+++ b/include/fieldproxy.h
@@ -197,6 +197,30 @@ public:
         return operator=(std::string(value));
     }
     
+    /**
+     *  Assign an array value
+     *  @param  value
+     *  @return FieldProxy
+     */
+    FieldProxy &operator=(const Array &value)
+    {
+        // assign value and allow chaining
+        _source->set(_index, value);
+        return *this;
+    }
+
+    /**
+     *  Assign a table value
+     *  @param  value
+     *  @return FieldProxy
+     */
+    FieldProxy &operator=(const Table &value)
+    {
+        // assign value and allow chaining
+        _source->set(_index, value);
+        return *this;
+    }
+    
     /**
      *  Get the underlying field
      *  @return Field
@@ -210,97 +234,8 @@ public:
      *  Get a boolean
      *  @return bool
      */
-    operator bool ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return int8_t
-     */
-    operator int8_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return uint8_t
-     */
-    operator uint8_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return int16_t
-     */
-    operator int16_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return uint16_t
-     */
-    operator uint16_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return int32_t
-     */
-    operator int32_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return uint32_t
-     */
-    operator uint32_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return int64_t
-     */
-    operator int64_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get numeric value
-     *  @return uint64_t
-     */
-    operator uint64_t ()
-    {
-        // retrieve the value
-        return _source->get(_index);
-    }
-
-    /**
-     *  Get string value
-     *  @return string
-     */
-    operator std::string ()
+    template <typename TARGET>
+    operator TARGET () const
     {
         // retrieve the value
         return _source->get(_index);
diff --git a/include/numericfield.h b/include/numericfield.h
index 9a60e4d..3cd4c93 100644
--- a/include/numericfield.h
+++ b/include/numericfield.h
@@ -78,10 +78,10 @@ public:
      *  Create a new instance of this object
      *  @return Field*
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
         // create a new copy of ourselves and return it
-        return new NumericField(_value);
+        return std::make_shared<NumericField>(_value);
     }
 
     /**
@@ -100,7 +100,7 @@ public:
      *  Get the value
      *  @return mixed
      */
-    operator T () const
+    virtual operator T () const override
     {
         return _value;
     }
diff --git a/include/stringfield.h b/include/stringfield.h
index 3def910..0408de7 100644
--- a/include/stringfield.h
+++ b/include/stringfield.h
@@ -58,10 +58,10 @@ public:
      *  Create a new instance of this object
      *  @return Field*
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
         // create a new copy of ourselves and return it
-        return new StringField(_data);
+        return std::make_shared<StringField>(_data);
     }
 
     /**
@@ -96,7 +96,7 @@ public:
      *  Get the value
      *  @return string
      */
-    operator const std::string& () const
+    virtual operator const std::string& () const override
     {
         return _data;
     }
diff --git a/include/table.h b/include/table.h
index 997c210..2faec2b 100644
--- a/include/table.h
+++ b/include/table.h
@@ -76,9 +76,9 @@ public:
      *  Create a new instance on the heap of this object, identical to the object passed
      *  @return Field*
      */
-    virtual Field *clone() const override
+    virtual std::shared_ptr<Field> clone() const override
     {
-        return new Table(*this);
+        return std::make_shared<Table>(*this);
     }
 
     /**
@@ -96,7 +96,7 @@ public:
     Table set(const std::string& name, const Field &value)
     {
         // copy to a new pointer and store it
-        _fields[name] = std::shared_ptr<Field>(value.clone());
+        _fields[name] = value.clone();
 
         // allow chaining
         return *this;
@@ -122,6 +122,16 @@ public:
         return AssociativeFieldProxy(this, name);
     }
 
+    /**
+     *  Get a field
+     *
+     *  @param  name    field name
+     */
+    AssociativeFieldProxy operator[](const char *name)
+    {
+        return AssociativeFieldProxy(this, name);
+    }
+
     /**
      *  Get a const field
      *
@@ -132,6 +142,16 @@ public:
         return get(name);
     }
 
+    /**
+     *  Get a const field
+     *
+     *  @param  name    field name
+     */
+    const Field &operator[](const char *name) const
+    {
+        return get(name);
+    }
+
     /**
      *  Write encoded payload to the given buffer. 
      *  @param  buffer
@@ -160,7 +180,7 @@ public:
         bool first = true;
         
         // loop through all members
-        for (auto iter : _fields) 
+        for (auto &iter : _fields) 
         {
             // split with comma
             if (!first) stream << ",";
@@ -175,6 +195,17 @@ public:
         // postfix
         stream << ")";
     }
+
+    /**
+     *  Cast to table
+     *  @return Table
+     */
+    virtual operator const Table& () const override
+    {
+        // this already is an array, so no cast is necessary
+        return *this;
+    }
+
 };
 
 /**
diff --git a/src/field.cpp b/src/field.cpp
index e49dc17..2655bb2 100644
--- a/src/field.cpp
+++ b/src/field.cpp
@@ -45,6 +45,45 @@ Field *Field::decode(ReceivedFrame &frame)
     }
 }
 
+/**
+ *  Cast to string
+ *  @return std::string
+ */
+Field::operator const std::string& () const
+{
+    // static empty string
+    static std::string empty;
+    
+    // return it
+    return empty;
+}
+
+/**
+ *  Cast to array
+ *  @return Array
+ */
+Field::operator const Array& () const
+{
+    // static empty array
+    static Array empty;
+    
+    // return it
+    return empty;
+}
+
+/**
+ *  Cast to object
+ *  @return Array
+ */
+Field::operator const Table& () const
+{
+    // static empty table
+    static Table empty;
+    
+    // return it
+    return empty;
+}
+
 /**
  *  End of namespace
  */

From d47d6bda5d7dd5a12c1fc4f8d37afd7e5dba4f81 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Mon, 14 Apr 2014 17:17:17 +0200
Subject: [PATCH 19/41] removed noreturn attribute because not supported on gcc
 4.7 (issue #10)

---
 src/methodframe.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/methodframe.h b/src/methodframe.h
index 8b847fd..c435df7 100644
--- a/src/methodframe.h
+++ b/src/methodframe.h
@@ -75,7 +75,7 @@ public:
      *  @param  connection      The connection over which it was received
      *  @return bool            Was it succesfully processed?
      */
-    virtual bool process[[ noreturn ]](ConnectionImpl *connection) override
+    virtual bool process(ConnectionImpl *connection) override
     {
         // this is an exception
         throw ProtocolException("unimplemented frame type " + std::to_string(type()) + " class " + std::to_string(classID()) + " method " + std::to_string(methodID()));

From 7b20f465192c23a30058bc1ef7d3180a90de8616 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 08:52:49 +0200
Subject: [PATCH 20/41] removed channel parameter from the callbacks, because
 this can easily be captured

---
 include/deferred.h         | 36 +++++++++++++++---------------------
 include/deferredconsumer.h | 12 ++++++------
 src/Makefile               |  2 +-
 src/channelimpl.cpp        |  5 +++--
 4 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/include/deferred.h b/include/deferred.h
index e2fb2d0..df4f9ed 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -27,17 +27,17 @@ private:
     /**
      *  Callback to execute on success
      */
-    std::function<void(Channel *channel, Arguments ...parameters)> _successCallback;
+    std::function<void(Arguments ...parameters)> _successCallback;
 
     /**
      *  Callback to execute on failure
      */
-    std::function<void(Channel *channel, const std::string& error)> _errorCallback;
+    std::function<void(const std::string& error)> _errorCallback;
 
     /**
      *  Callback to execute either way
      */
-    std::function<void(Channel *channel, const std::string& error)> _finalizeCallback;
+    std::function<void(const std::string& error)> _finalizeCallback;
 
     /**
      *  Indicate success
@@ -47,8 +47,8 @@ private:
     void success(Arguments ...parameters) const
     {
         // execute callbacks if registered
-        if (_successCallback)   _successCallback(_channel, parameters...);
-        if (_finalizeCallback)  _finalizeCallback(_channel, "");
+        if (_successCallback)   _successCallback(parameters...);
+        if (_finalizeCallback)  _finalizeCallback("");
     }
 
     /**
@@ -59,8 +59,8 @@ private:
     void error(const std::string& error) const
     {
         // execute callbacks if registered
-        if (_errorCallback)     _errorCallback(_channel, error);
-        if (_finalizeCallback)  _finalizeCallback(_channel, error);
+        if (_errorCallback)     _errorCallback(error);
+        if (_finalizeCallback)  _finalizeCallback(error);
     }
 
     /**
@@ -69,14 +69,11 @@ private:
      */
     friend class ChannelImpl;
     friend class Callbacks;
+    
 protected:
-    /**
-     *  The channel we operate under
-     */
-    Channel *_channel;
-
     /**
      *  Do we already know we failed?
+     *  @var bool
      */
     bool _failed;
 
@@ -84,13 +81,10 @@ protected:
      *  Protected constructor that can only be called
      *  from within the channel implementation
      *
-     *  @param  channel the channel we operate under
-     *  @param  boolea  are we already failed?
+     *  @param  failed  are we already failed?
      */
-    Deferred(Channel *channel, bool failed = false) :
-        _channel(channel),
-        _failed(failed)
-    {}
+    Deferred(bool failed = false) : _failed(failed) {}
+
 public:
     /**
      *  Deleted copy constructor
@@ -125,7 +119,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onSuccess(const std::function<void(Channel *channel, Arguments ...parameters)>& callback)
+    Deferred& onSuccess(const std::function<void(Arguments ...parameters)>& callback)
     {
         // store callback
         _successCallback = callback;
@@ -142,7 +136,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onError(const std::function<void(Channel *channel, const std::string& error)>& callback)
+    Deferred& onError(const std::function<void(const std::string& error)>& callback)
     {
         // store callback
         _errorCallback = callback;
@@ -164,7 +158,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onFinalize(const std::function<void(Channel *channel, const std::string& error)>& callback)
+    Deferred& onFinalize(const std::function<void(const std::string& error)>& callback)
     {
         // store callback
         _finalizeCallback = callback;
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
index 3610bd7..8de39bd 100644
--- a/include/deferredconsumer.h
+++ b/include/deferredconsumer.h
@@ -20,7 +20,7 @@ private:
     /**
      *  Callback to execute when a message arrives
      */
-    std::function<void(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)> _messageCallback;
+    std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)> _messageCallback;
 
     /**
      *  Process a message
@@ -33,7 +33,7 @@ private:
     void message(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) const
     {
         // do we have a valid callback
-        if (_messageCallback) _messageCallback(_channel, message, deliveryTag, consumerTag, redelivered);
+        if (_messageCallback) _messageCallback(message, deliveryTag, consumerTag, redelivered);
     }
 
     /**
@@ -42,6 +42,7 @@ private:
      */
     friend class ChannelImpl;
     friend class ConsumedMessage;
+    
 protected:
     /**
      *  Protected constructor that can only be called
@@ -50,9 +51,8 @@ protected:
      *  @param  channel the channel we operate under
      *  @param  boolea  are we already failed?
      */
-    DeferredConsumer(Channel *channel, bool failed = false) :
-        Deferred(channel, failed)
-    {}
+    DeferredConsumer(bool failed = false) : Deferred(failed) {}
+
 public:
     /**
      *  Register a function to be called when a message arrives
@@ -62,7 +62,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer& onReceived(const std::function<void(Channel *channel, const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>& callback)
+    DeferredConsumer& onReceived(const std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>& callback)
     {
         // store callback
         _messageCallback = callback;
diff --git a/src/Makefile b/src/Makefile
index 3a9b4e9..4f0baa2 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,6 +1,6 @@
 CPP			    = g++
 RM			    = rm -f
-CPPFLAGS		= -Wall -c -I. -O2 -flto -std=c++11 -g
+CPPFLAGS		= -Wall -c -I. -g -flto -std=c++11 -g
 LD			    = g++
 LD_FLAGS		= -Wall -shared -O2
 SHARED_LIB		= libamqpcpp.so
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 4609d0d..a478dff 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -439,7 +439,7 @@ Deferred<>& ChannelImpl::setQos(uint16_t prefetchCount)
 DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments)
 {
     // create the deferred consumer
-    _consumer = std::unique_ptr<DeferredConsumer>(new DeferredConsumer(_parent, false));
+    _consumer = std::unique_ptr<DeferredConsumer>(new DeferredConsumer(false));
 
     // can we send the basic consume frame?
     if (!send(BasicConsumeFrame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments)))
@@ -542,7 +542,7 @@ Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *messag
     // create a new deferred handler and get a pointer to it
     // note: cannot use auto here or the lambda below chokes
     // when compiling under gcc 4.8
-    Deferred<Arguments...> *handler = &_callbacks.push_back(Deferred<Arguments...>(_parent));
+    Deferred<Arguments...> *handler = &_callbacks.push_back(Deferred<Arguments...>());
 
     // send the frame over the channel
     if (!send(frame))
@@ -554,6 +554,7 @@ Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *messag
         // after a timeout, so it gets called only
         // after a possible handler was installed.
         _connection->_handler->setTimeout(_connection->_parent, 0, [handler, message]() {
+            
             // emit an error on the handler
             handler->error(message);
         });

From 921f24ae06b61bfbfd2a5045cd28759ed465dd8e Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 10:43:33 +0200
Subject: [PATCH 21/41] de-templified the deferred objects, to make them easier
 to understand for other programmers

---
 amqpcpp.h                  |   5 +-
 include/callbacks.h        | 149 +++-----------------------------
 include/channel.h          |  74 ++++++++--------
 include/channelimpl.h      | 102 ++++++++++++++--------
 include/deferred.h         | 143 +++++++++++++++++++++++--------
 include/deferredcancel.h   |  91 ++++++++++++++++++++
 include/deferredconsumer.h |  17 ++--
 include/deferreddelete.h   |  91 ++++++++++++++++++++
 include/deferredqueue.h    |  91 ++++++++++++++++++++
 src/channelimpl.cpp        | 168 +++++++++++++++++++++++--------------
 src/queuedeclareokframe.h  |   4 +-
 11 files changed, 623 insertions(+), 312 deletions(-)
 create mode 100644 include/deferredcancel.h
 create mode 100644 include/deferreddelete.h
 create mode 100644 include/deferredqueue.h

diff --git a/amqpcpp.h b/amqpcpp.h
index 9f84823..06f19f8 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -53,9 +53,12 @@
 // mid level includes
 #include <amqpcpp/exchangetype.h>
 #include <amqpcpp/flags.h>
+#include <amqpcpp/callbacks.h>
 #include <amqpcpp/deferred.h>
 #include <amqpcpp/deferredconsumer.h>
-#include <amqpcpp/callbacks.h>
+#include <amqpcpp/deferredqueue.h>
+#include <amqpcpp/deferreddelete.h>
+#include <amqpcpp/deferredcancel.h>
 #include <amqpcpp/channelimpl.h>
 #include <amqpcpp/channel.h>
 #include <amqpcpp/login.h>
diff --git a/include/callbacks.h b/include/callbacks.h
index 9d378df..50239a0 100644
--- a/include/callbacks.h
+++ b/include/callbacks.h
@@ -12,145 +12,18 @@
 namespace AMQP {
 
 /**
- *  Class for managing deferred callbacks
+ *  All the callbacks that are supported
+ * 
+ *  When someone registers a callback function for certain events, it should
+ *  match one of the following signatures.
  */
-class Callbacks
-{
-private:
-    /**
-     *  Different callback types supported
-     */
-    std::tuple<
-        std::deque<Deferred<>>,
-        std::deque<Deferred<const std::string&, uint32_t, uint32_t>>,
-        std::deque<Deferred<uint32_t>>,
-        std::deque<Deferred<const std::string&>>
-    > _callbacks;
-
-    /**
-     *  If all else fails, we have gotten the wrong
-     *  type, which is not present in the arguments.
-     *
-     *  This should result in a compile error.
-     */
-    template <class T, std::size_t N, class... Arguments>
-    struct getIndex
-    {
-        // if this structure is used, we went past the last argument
-        // and this static_assert should trigger a compile failure.
-        static_assert(N < sizeof...(Arguments), "Type T not found in Arguments");
-
-        // we still have to provide this member though
-        static constexpr std::size_t value = N;
-    };
-
-    /**
-     *  This structure has one static member that represents
-     *  the index of T in Arguments. This variant is used where U
-     *  does equal T, so a match is found, meaning the current
-     *  index given is the right one.
-     */
-    template <class T, std::size_t N, class... Arguments>
-    struct getIndex<T, N, T, Arguments...>
-    {
-        // element is same type as we are looking for
-        static constexpr std::size_t value = N;
-    };
-
-    /**
-     *  This structure has one static member that represents
-     *  the index of T in Arguments. This variant is used where U
-     *  does not equal T, so we need to look at the next member.
-     */
-    template <class T, std::size_t N, class U, class... Arguments>
-    struct getIndex<T, N, U, Arguments...>
-    {
-        // current N is not correct, unroll to next element
-        static constexpr std::size_t value = getIndex<T, N + 1, Arguments...>::value;
-    };
-
-    /**
-     *  Retrieve the list of callbacks matching the type
-     *
-     *  @param  tuple   tuple with callbacks
-     */
-    template <class T, class... Arguments>
-    T& get(std::tuple<Arguments...>& tuple)
-    {
-        // retrieve the index at which the requested callbacks can be found
-        constexpr std::size_t index = getIndex<T, 0, Arguments...>::value;
-
-        // retrieve the callbacks
-        return std::get<index>(tuple);
-    }
-public:
-    /**
-     *  Add a deferred to the available callbacks
-     *
-     *  @param  deferred    the deferred to add
-     *  @return reference to the inserted deferred
-     */
-    template <typename... Arguments>
-    Deferred<Arguments...>& push_back(Deferred<Arguments...>&& item)
-    {
-        // retrieve the container
-        auto &container = get<std::deque<Deferred<Arguments...>>>(_callbacks);
-
-        // add the element
-        container.push_back(std::move(item));
-
-        // return reference to the new item
-        return container.back();
-    }
-
-    /**
-     *  Report success to the relevant callback
-     *
-     *  @param  mixed...    additional parameters
-     */
-    template <typename... Arguments>
-    void reportSuccess(Arguments ...parameters)
-    {
-        // retrieve the container and element
-        auto &container = get<std::deque<Deferred<Arguments...>>>(_callbacks);
-        auto &callback  = container.front();
-
-        // execute the callback
-        callback.success(parameters...);
-
-        // remove the executed callback
-        container.pop_front();
-    }
-
-    /**
-     *  Report a failure
-     *
-     *  @param  error   a description of the error
-     */
-    template <std::size_t N = 0>
-    typename std::enable_if<N == std::tuple_size<decltype(_callbacks)>::value>::type
-    reportError(const std::string& message)
-    {}
-
-    /**
-     *  Report a failure
-     *
-     *  @param  error   a description of the error
-     */
-    template <std::size_t N = 0>
-    typename std::enable_if<N < std::tuple_size<decltype(_callbacks)>::value>::type
-    reportError(const std::string& message)
-    {
-        // retrieve the callbacks at current index
-        auto &callbacks = std::get<N>(_callbacks);
-
-        // report errors to all callbacks of the current type
-        for (auto &callback : callbacks) callback.error(message);
-
-        // execute the next type
-        reportError<N + 1>(message);
-    }
-};
+using SuccessCallback   =   std::function<void()>;
+using ErrorCallback     =   std::function<void(const char *message)>;
+using FinalizeCallback  =   std::function<void()>;
+using ConsumeCallback   =   std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>;
+using QueueCallback     =   std::function<void(const std::string &name, uint32_t messagecount, uint32_t consumercount)>;
+using DeleteCallback    =   std::function<void(uint32_t deletedmessages)>;
+using CancelCallback    =   std::function<void(const std::string &consumer)>;
 
 /**
  *  End namespace
diff --git a/include/channel.h b/include/channel.h
index e5df3d3..0f315c4 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -42,7 +42,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    void onReady(const std::function<void(Channel *channel)>& callback)
+    void onReady(const SuccessCallback &callback)
     {
         // store callback in implementation
         _implementation._readyCallback = callback;
@@ -56,7 +56,7 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    void onError(const std::function<void(Channel *channel, const std::string& message)>& callback)
+    void onError(const ErrorCallback &callback)
     {
         // store callback in implementation
         _implementation._errorCallback = callback;
@@ -70,7 +70,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& pause()
+    Deferred &pause()
     {
         return _implementation.pause();
     }
@@ -83,7 +83,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& resume()
+    Deferred &resume()
     {
         return _implementation.resume();
     }
@@ -103,7 +103,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& startTransaction()
+    Deferred &startTransaction()
     {
         return _implementation.startTransaction();
     }
@@ -114,7 +114,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& commitTransaction()
+    Deferred &commitTransaction()
     {
         return _implementation.commitTransaction();
     }
@@ -125,7 +125,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& rollbackTransaction()
+    Deferred &rollbackTransaction()
     {
         return _implementation.rollbackTransaction();
     }
@@ -149,12 +149,12 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(name, type, flags, arguments); }
-    Deferred<>& declareExchange(const std::string &name, ExchangeType type, const Table &arguments) { return _implementation.declareExchange(name, type, 0, arguments); }
-    Deferred<>& declareExchange(const std::string &name, ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(name, type, flags, Table()); }
-    Deferred<>& declareExchange(ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(std::string(), type, flags, arguments); }
-    Deferred<>& declareExchange(ExchangeType type, const Table &arguments) { return _implementation.declareExchange(std::string(), type, 0, arguments); }
-    Deferred<>& declareExchange(ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(std::string(), type, flags, Table()); }
+    Deferred &declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(name, type, flags, arguments); }
+    Deferred &declareExchange(const std::string &name, ExchangeType type, const Table &arguments) { return _implementation.declareExchange(name, type, 0, arguments); }
+    Deferred &declareExchange(const std::string &name, ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(name, type, flags, Table()); }
+    Deferred &declareExchange(ExchangeType type, int flags, const Table &arguments) { return _implementation.declareExchange(std::string(), type, flags, arguments); }
+    Deferred &declareExchange(ExchangeType type, const Table &arguments) { return _implementation.declareExchange(std::string(), type, 0, arguments); }
+    Deferred &declareExchange(ExchangeType type = fanout, int flags = 0) { return _implementation.declareExchange(std::string(), type, flags, Table()); }
 
     /**
      *  Remove an exchange
@@ -169,7 +169,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& removeExchange(const std::string &name, int flags = 0) { return _implementation.removeExchange(name, flags); }
+    Deferred &removeExchange(const std::string &name, int flags = 0) { return _implementation.removeExchange(name, flags); }
 
     /**
      *  Bind two exchanges to each other
@@ -187,9 +187,9 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, flags, arguments); }
-    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, 0, arguments); }
-    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags = 0) { return _implementation.bindExchange(source, target, routingkey, flags, Table()); }
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, flags, arguments); }
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, 0, arguments); }
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags = 0) { return _implementation.bindExchange(source, target, routingkey, flags, Table()); }
 
     /**
      *  Unbind two exchanges from one another
@@ -207,9 +207,9 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, flags, arguments); }
-    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, 0, arguments); }
-    Deferred<>& unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags = 0) { return _implementation.unbindExchange(target, source, routingkey, flags, Table()); }
+    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, flags, arguments); }
+    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, 0, arguments); }
+    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags = 0) { return _implementation.unbindExchange(target, source, routingkey, flags, Table()); }
 
     /**
      *  Declare a queue
@@ -240,12 +240,12 @@ public:
      *
      *  });
      */
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments) { return _implementation.declareQueue(name, flags, arguments); }
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, const Table &arguments) { return _implementation.declareQueue(name, 0, arguments); }
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags = 0) { return _implementation.declareQueue(name, flags, Table()); }
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags, const Table &arguments) { return _implementation.declareQueue(std::string(), flags, arguments); }
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const Table &arguments) { return _implementation.declareQueue(std::string(), 0, arguments); }
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags = 0) { return _implementation.declareQueue(std::string(), flags, Table()); }
+    DeferredQueue &declareQueue(const std::string &name, int flags, const Table &arguments) { return _implementation.declareQueue(name, flags, arguments); }
+    DeferredQueue &declareQueue(const std::string &name, const Table &arguments) { return _implementation.declareQueue(name, 0, arguments); }
+    DeferredQueue &declareQueue(const std::string &name, int flags = 0) { return _implementation.declareQueue(name, flags, Table()); }
+    DeferredQueue &declareQueue(int flags, const Table &arguments) { return _implementation.declareQueue(std::string(), flags, arguments); }
+    DeferredQueue &declareQueue(const Table &arguments) { return _implementation.declareQueue(std::string(), 0, arguments); }
+    DeferredQueue &declareQueue(int flags = 0) { return _implementation.declareQueue(std::string(), flags, Table()); }
 
     /**
      *  Bind a queue to an exchange
@@ -263,9 +263,9 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, flags, arguments); }
-    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, 0, arguments); }
-    Deferred<>& bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags = 0) { return _implementation.bindQueue(exchange, queue, routingkey, flags, Table()); }
+    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, flags, arguments); }
+    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, 0, arguments); }
+    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags = 0) { return _implementation.bindQueue(exchange, queue, routingkey, flags, Table()); }
 
     /**
      *  Unbind a queue from an exchange
@@ -277,8 +277,8 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) {  return _implementation.unbindQueue(exchange, queue, routingkey, arguments); }
-    Deferred<>& unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey) { return _implementation.unbindQueue(exchange, queue, routingkey, Table()); }
+    Deferred &unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) {  return _implementation.unbindQueue(exchange, queue, routingkey, arguments); }
+    Deferred &unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey) { return _implementation.unbindQueue(exchange, queue, routingkey, Table()); }
 
     /**
      *  Purge a queue
@@ -303,7 +303,7 @@ public:
      *
      *  });
      */
-    Deferred<uint32_t>& purgeQueue(const std::string &name, int flags = 0){ return _implementation.purgeQueue(name, flags); }
+    DeferredDelete &purgeQueue(const std::string &name, int flags = 0){ return _implementation.purgeQueue(name, flags); }
 
     /**
      *  Remove a queue
@@ -329,7 +329,7 @@ public:
      *
      *  });
      */
-    Deferred<uint32_t>& removeQueue(const std::string &name, int flags = 0) { return _implementation.removeQueue(name, flags); }
+    DeferredDelete &removeQueue(const std::string &name, int flags = 0) { return _implementation.removeQueue(name, flags); }
 
     /**
      *  Publish a message to an exchange
@@ -361,7 +361,7 @@ public:
      *  @param  prefetchCount       maximum number of messages to prefetch
      *  @return bool                whether the Qos frame is sent.
      */
-    Deferred<>& setQos(uint16_t prefetchCount)
+    Deferred &setQos(uint16_t prefetchCount)
     {
         return _implementation.setQos(prefetchCount);
     }
@@ -440,7 +440,7 @@ public:
      *
      *  });
      */
-    Deferred<const std::string&>& cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
+    DeferredCancel &cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
 
     /**
      *  Acknoldge a received message
@@ -493,7 +493,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& recover(int flags = 0) { return _implementation.recover(flags); }
+    Deferred &recover(int flags = 0) { return _implementation.recover(flags); }
 
     /**
      *  Close the current channel
@@ -501,7 +501,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& close() { return _implementation.close(); }
+    Deferred &close() { return _implementation.close(); }
 
     /**
      *  Get the channel we're working on
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 37e8e07..43a87ba 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -34,24 +34,38 @@ private:
 
     /**
      *  Callback when the channel is ready
+     *  @var    SuccessCallback
      */
-    std::function<void(Channel *channel)> _readyCallback;
+    SuccessCallback _readyCallback;
 
     /**
      *  Callback when the channel errors out
+     *  @var    ErrorCallback
      */
-    std::function<void(Channel *channel, const std::string& message)> _errorCallback;
+    ErrorCallback _errorCallback;
 
     /**
      *  Callback to execute when a message arrives
+     * 
+     *  @todo   do this different??
      */
     std::unique_ptr<DeferredConsumer> _consumer;
 
     /**
-     *  The callbacks waiting to be called
+     *  Pointer to the oldest deferred result (the first one that is going
+     *  to be executed)
+     * 
+     *  @var    Deferred
      */
-    Callbacks _callbacks;
-
+    Deferred *_oldestCallback = nullptr;
+    
+    /**
+     *  Pointer to the newest deferred result (the last one to be added).
+     * 
+     *  @var    Deferred
+     */
+    Deferred *_newestCallback = nullptr;
+    
     /**
      *  The channel number
      *  @var uint16_t
@@ -86,6 +100,14 @@ private:
      */
     ChannelImpl(Channel *parent, Connection *connection);
 
+    /**
+     *  Push a deferred result
+     *  @param  result          The deferred result
+     *  @param  error           Error message in case the result is not ok
+     */
+    void push(Deferred *deferred, const char *error);
+
+
 public:
     /**
      *  Destructor
@@ -109,7 +131,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& pause();
+    Deferred &pause();
 
     /**
      *  Resume a paused channel
@@ -119,7 +141,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& resume();
+    Deferred &resume();
 
     /**
      *  Is the channel connected?
@@ -133,7 +155,7 @@ public:
     /**
      *  Start a transaction
      */
-    Deferred<>& startTransaction();
+    Deferred &startTransaction();
 
     /**
      *  Commit the current transaction
@@ -141,7 +163,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& commitTransaction();
+    Deferred &commitTransaction();
 
     /**
      *  Rollback the current transaction
@@ -149,7 +171,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& rollbackTransaction();
+    Deferred &rollbackTransaction();
 
     /**
      *  declare an exchange
@@ -162,7 +184,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments);
+    Deferred &declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments);
 
     /**
      *  bind two exchanges
@@ -176,7 +198,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
 
     /**
      *  unbind two exchanges
@@ -190,7 +212,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
 
     /**
      *  remove an exchange
@@ -201,7 +223,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& removeExchange(const std::string &name, int flags);
+    Deferred &removeExchange(const std::string &name, int flags);
 
     /**
      *  declare a queue
@@ -212,7 +234,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments);
+    DeferredQueue &declareQueue(const std::string &name, int flags, const Table &arguments);
 
     /**
      *  Bind a queue to an exchange
@@ -226,7 +248,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments);
 
     /**
      *  Unbind a queue from an exchange
@@ -239,7 +261,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& unbindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments);
+    Deferred &unbindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments);
 
     /**
      *  Purge a queue
@@ -259,7 +281,7 @@ public:
      *
      *  });
      */
-    Deferred<uint32_t>& purgeQueue(const std::string &name, int flags);
+    DeferredDelete &purgeQueue(const std::string &name, int flags);
 
     /**
      *  Remove a queue
@@ -279,7 +301,7 @@ public:
      *
      *  });
      */
-    Deferred<uint32_t>& removeQueue(const std::string &name, int flags);
+    DeferredDelete &removeQueue(const std::string &name, int flags);
 
     /**
      *  Publish a message to an exchange
@@ -303,7 +325,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& setQos(uint16_t prefetchCount);
+    Deferred &setQos(uint16_t prefetchCount);
 
     /**
      *  Tell the RabbitMQ server that we're ready to consume messages
@@ -345,7 +367,7 @@ public:
      *
      *  });
      */
-    Deferred<const std::string&>& cancel(const std::string &tag, int flags);
+    DeferredCancel &cancel(const std::string &tag, int flags);
 
     /**
      *  Acknowledge a message
@@ -370,7 +392,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& recover(int flags);
+    Deferred &recover(int flags);
 
     /**
      *  Close the current channel
@@ -378,7 +400,7 @@ public:
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred<>& close();
+    Deferred &close();
 
     /**
      *  Get the channel we're working on
@@ -402,9 +424,9 @@ public:
      *
      *  @param  frame       frame to send
      *  @param  message     the message to trigger if the frame cannot be send at all
+     *  @return Deferred    the deferred object
      */
-    template <typename... Arguments>
-    Deferred<Arguments...>& send(const Frame &frame, const char *message);
+    Deferred &send(const Frame &frame, const char *message);
 
     /**
      *  Report to the handler that the channel is opened
@@ -412,7 +434,7 @@ public:
     void reportReady()
     {
         // inform handler
-        if (_readyCallback) _readyCallback(_parent);
+        if (_readyCallback) _readyCallback();
     }
 
     /**
@@ -436,8 +458,13 @@ public:
     template <typename... Arguments>
     void reportSuccess(Arguments ...parameters)
     {
-        // report success to the relevant callback
-        _callbacks.reportSuccess<Arguments...>(std::forward<Arguments>(parameters)...);
+        // skip if there is no oldest callback
+        if (!_oldestCallback) return;
+        
+        // report to the oldest callback, and install a new oldest callback
+        _oldestCallback = _oldestCallback->reportSuccess(std::forward<Arguments>(parameters)...);
+        
+        // @todo destruct oldest callback
     }
 
     /**
@@ -449,11 +476,19 @@ public:
         // change state
         _state = state_closed;
 
-        // inform handler
-        if (_errorCallback) _errorCallback(_parent, message);
+        // @todo    multiple callbacks are called, this could break
+        // @todo    should this be a std::string parameter?
 
-        // report to all waiting callbacks too
-        _callbacks.reportError(message);
+        // inform handler
+        if (_errorCallback) _errorCallback(message.c_str());
+
+        // skip if there is no oldest callback
+        if (!_oldestCallback) return;
+
+        // report to the oldest callback, and install a new oldest callback
+        _oldestCallback = _oldestCallback->reportError(message);
+
+        // @todo destruct oldest callback
     }
 
     /**
@@ -488,7 +523,8 @@ public:
         if (!_consumer) reportError("Received basic consume ok frame, but no consumer was found");
 
         // otherwise, we now report the consumer as started
-        else _consumer->success(consumerTag);
+        // @todo look at this implementation
+        //else _consumer->success(consumerTag);
     }
 
     /**
diff --git a/include/deferred.h b/include/deferred.h
index df4f9ed..777a370 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -20,47 +20,132 @@ class Callbacks;
 /**
  *  Class definition
  */
-template <typename... Arguments>
 class Deferred
 {
-private:
+protected:
     /**
      *  Callback to execute on success
+     *  @var    SuccessCallback
      */
-    std::function<void(Arguments ...parameters)> _successCallback;
+    SuccessCallback _successCallback;
 
     /**
      *  Callback to execute on failure
+     *  @var    ErrorCallback
      */
-    std::function<void(const std::string& error)> _errorCallback;
+    ErrorCallback _errorCallback;
 
     /**
      *  Callback to execute either way
+     *  @var    FinalizeCallback
      */
-    std::function<void(const std::string& error)> _finalizeCallback;
+    FinalizeCallback _finalizeCallback;
+
+    /**
+     *  Pointer to the next deferred object
+     *  @var    Deferred
+     */
+    Deferred *_next = nullptr;
+
+    /**
+     *  Do we already know we failed?
+     *  @var bool
+     */
+    bool _failed;
+
 
     /**
      *  Indicate success
-     *
-     *  @param  parameters...   the extra parameters relevant for this deferred handler
+     *  @return Deferred        Next deferred result
      */
-    void success(Arguments ...parameters) const
+    Deferred *reportSuccess() const
     {
         // execute callbacks if registered
-        if (_successCallback)   _successCallback(parameters...);
-        if (_finalizeCallback)  _finalizeCallback("");
+        if (_successCallback)   _successCallback();
+        if (_finalizeCallback)  _finalizeCallback();
+        
+        // return the next deferred result
+        return _next;
+    }
+    
+    /**
+     *  Report success for queue declared messages
+     *  @param  name            Name of the new queue
+     *  @param  messagecount    Number of messages in the queue
+     *  @param  consumercount   Number of consumers linked to the queue
+     *  @return Deferred        Next deferred result
+     */
+    virtual Deferred *reportSuccess(const std::string &name, uint32_t messagecount, uint32_t consumercount) const
+    {
+        // this is the same as a regular success message
+        return reportSuccess();
+    }
+    
+    /**
+     *  Report success for frames that report delete operations
+     *  @param  messagecount    Number of messages that were deleted
+     *  @return Deferred
+     */
+    virtual Deferred *reportSuccess(uint32_t messagecount) const
+    {
+        // this is the same as a regular success message
+        return reportSuccess();
+    }
+    
+    /**
+     *  Report success for frames that report cancel operations
+     *  @param  name            Consumer tag that is cancelled
+     *  @return Deferred
+     */
+    virtual Deferred *reportSuccess(const std::string &name) const
+    {
+        // this is the same as a regular success message
+        return reportSuccess();
+    }
+
+    /**
+     *  Indicate failure
+     *  @param  error           Description of the error that occured
+     *  @return Deferred        Next deferred result
+     */
+    Deferred *reportError(const std::string& error) 
+    {
+        // from this moment on the object should be listed as failed
+        _failed = true;
+        
+        // execute callbacks if registered
+        if (_errorCallback)     _errorCallback(error.c_str());
+        if (_finalizeCallback)  _finalizeCallback();
+        
+        // return the next deferred result
+        return _next;
     }
 
     /**
      *  Indicate failure
-     *
      *  @param  error   description of the error that occured
      */
-    void error(const std::string& error) const
+    Deferred *reportError(const char *error) 
     {
+        // from this moment on the object should be listed as failed
+        _failed = true;
+
         // execute callbacks if registered
         if (_errorCallback)     _errorCallback(error);
-        if (_finalizeCallback)  _finalizeCallback(error);
+        if (_finalizeCallback)  _finalizeCallback();
+        
+        // return the next deferred result
+        return _next;
+    }
+
+    /**
+     *  Add a pointer to the next deferred result
+     *  @param  deferred
+     */
+    void add(Deferred *deferred)
+    {
+        // store pointer
+        _next = deferred;
     }
 
     /**
@@ -71,12 +156,6 @@ private:
     friend class Callbacks;
     
 protected:
-    /**
-     *  Do we already know we failed?
-     *  @var bool
-     */
-    bool _failed;
-
     /**
      *  Protected constructor that can only be called
      *  from within the channel implementation
@@ -87,18 +166,10 @@ protected:
 
 public:
     /**
-     *  Deleted copy constructor
+     *  Deleted copy and move constructors
      */
-    Deferred(const Deferred& that) = delete;
-
-    /**
-     *  Move constructor
-     */
-    Deferred(Deferred&& that) :
-        _successCallback(std::move(that._successCallback)),
-        _errorCallback(std::move(that._errorCallback)),
-        _finalizeCallback(std::move(that._finalizeCallback))
-    {}
+    Deferred(const Deferred &that) = delete;
+    Deferred(Deferred &&that) = delete;
 
     /**
      *  Cast to a boolean
@@ -119,10 +190,12 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onSuccess(const std::function<void(Arguments ...parameters)>& callback)
+    Deferred &onSuccess(const SuccessCallback &callback)
     {
         // store callback
         _successCallback = callback;
+        
+        // allow chaining
         return *this;
     }
 
@@ -136,10 +209,12 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onError(const std::function<void(const std::string& error)>& callback)
+    Deferred &onError(const ErrorCallback &callback)
     {
         // store callback
         _errorCallback = callback;
+        
+        // allow chaining
         return *this;
     }
 
@@ -158,10 +233,12 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred& onFinalize(const std::function<void(const std::string& error)>& callback)
+    Deferred &onFinalize(const FinalizeCallback &callback)
     {
         // store callback
         _finalizeCallback = callback;
+        
+        // allow chaining
         return *this;
     }
 };
diff --git a/include/deferredcancel.h b/include/deferredcancel.h
new file mode 100644
index 0000000..401716d
--- /dev/null
+++ b/include/deferredcancel.h
@@ -0,0 +1,91 @@
+/**
+ *  DeferredCancel.h
+ *
+ *  Deferred callback for instructions that cancel a running consumer. This
+ *  deferred object allows one to register a callback that also gets the
+ *  consumer tag as one of its parameters.
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  We extend from the default deferred and add extra functionality
+ */
+class DeferredCancel : public Deferred
+{
+private:
+    /**
+     *  Callback to execute when the instruction is completed
+     *  @var    CancelCallback
+     */
+    CancelCallback _cancelCallback;
+
+    /**
+     *  Report success for frames that report cancel operations
+     *  @param  name            Consumer tag that is cancelled
+     *  @return Deferred
+     */
+    virtual Deferred *reportSuccess(const std::string &name) const override
+    {
+        // skip if no special callback was installed
+        if (!_cancelCallback) return Deferred::reportSuccess();
+        
+        // call the callback
+        _cancelCallback(name);
+        
+        // call finalize callback
+        if (_finalizeCallback) _finalizeCallback();
+        
+        // return next object
+        return _next;
+    }
+
+    /**
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+    friend class ConsumedMessage;
+    
+protected:
+    /**
+     *  Protected constructor that can only be called
+     *  from within the channel implementation
+     *
+     *  @param  boolean     are we already failed?
+     */
+    DeferredCancel(bool failed = false) : Deferred(failed) {}
+
+public:
+    /**
+     *  Register a function to be called when the cancel operation succeeded
+     *
+     *  Only one callback can be registered. Successive calls
+     *  to this function will clear callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    DeferredCancel &onSuccess(const CancelCallback &callback)
+    {
+        // store callback
+        _cancelCallback = callback;
+        
+        // allow chaining
+        return *this;
+    }
+
+    /**
+     *  All the onSuccess() functions defined in the base class are accessible too
+     */
+    using Deferred::onSuccess;
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
index 8de39bd..c1555ad 100644
--- a/include/deferredconsumer.h
+++ b/include/deferredconsumer.h
@@ -14,13 +14,14 @@ namespace AMQP {
 /**
  *  We extend from the default deferred and add extra functionality
  */
-class DeferredConsumer : public Deferred<const std::string&>
+class DeferredConsumer : public Deferred
 {
 private:
     /**
      *  Callback to execute when a message arrives
+     *  @var    ConsumeCallbacl
      */
-    std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)> _messageCallback;
+    ConsumeCallback _consumeCallback;
 
     /**
      *  Process a message
@@ -33,7 +34,7 @@ private:
     void message(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) const
     {
         // do we have a valid callback
-        if (_messageCallback) _messageCallback(message, deliveryTag, consumerTag, redelivered);
+        if (_consumeCallback) _consumeCallback(message, deliveryTag, consumerTag, redelivered);
     }
 
     /**
@@ -48,7 +49,6 @@ protected:
      *  Protected constructor that can only be called
      *  from within the channel implementation
      *
-     *  @param  channel the channel we operate under
      *  @param  boolea  are we already failed?
      */
     DeferredConsumer(bool failed = false) : Deferred(failed) {}
@@ -62,12 +62,17 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer& onReceived(const std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>& callback)
+    DeferredConsumer& onReceived(const ConsumeCallback &callback)
     {
         // store callback
-        _messageCallback = callback;
+        _consumeCallback = callback;
         return *this;
     }
+
+    /**
+     *  All the onSuccess() functions defined in the base class are accessible too
+     */
+    using Deferred::onSuccess;
 };
 
 /**
diff --git a/include/deferreddelete.h b/include/deferreddelete.h
new file mode 100644
index 0000000..43ada61
--- /dev/null
+++ b/include/deferreddelete.h
@@ -0,0 +1,91 @@
+/**
+ *  DeferredDelete.h
+ *
+ *  Deferred callback for instructions that delete or purge queues, and that
+ *  want to report the number of deleted messages.
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  We extend from the default deferred and add extra functionality
+ */
+class DeferredDelete : public Deferred
+{
+private:
+    /**
+     *  Callback to execute when the instruction is completed
+     *  @var    DeleteCallback
+     */
+    DeleteCallback _deleteCallback;
+
+    /**
+     *  Report success for queue delete and queue purge messages
+     *  @param  messagecount    Number of messages that were deleted
+     *  @return Deferred        Next deferred result
+     */
+    virtual Deferred *reportSuccess(uint32_t messagecount) const override
+    {
+        // skip if no special callback was installed
+        if (!_deleteCallback) return Deferred::reportSuccess();
+        
+        // call the callback
+        _deleteCallback(messagecount);
+        
+        // call finalize callback
+        if (_finalizeCallback) _finalizeCallback();
+        
+        // return next object
+        return _next;
+    }
+
+
+    /**
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+    friend class ConsumedMessage;
+    
+protected:
+    /**
+     *  Protected constructor that can only be called
+     *  from within the channel implementation
+     *
+     *  @param  boolean     are we already failed?
+     */
+    DeferredDelete(bool failed = false) : Deferred(failed) {}
+
+public:
+    /**
+     *  Register a function to be called when the queue is deleted or purged
+     *
+     *  Only one callback can be registered. Successive calls
+     *  to this function will clear callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    DeferredDelete &onSuccess(const DeleteCallback &callback)
+    {
+        // store callback
+        _deleteCallback = callback;
+        
+        // allow chaining
+        return *this;
+    }
+
+    /**
+     *  All the onSuccess() functions defined in the base class are accessible too
+     */
+    using Deferred::onSuccess;
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/include/deferredqueue.h b/include/deferredqueue.h
new file mode 100644
index 0000000..085f095
--- /dev/null
+++ b/include/deferredqueue.h
@@ -0,0 +1,91 @@
+/**
+ *  DeferredQueue.h
+ *
+ *  Deferred callback for "declare-queue" instructions.
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Set up namespace
+ */
+namespace AMQP {
+
+/**
+ *  We extend from the default deferred and add extra functionality
+ */
+class DeferredQueue : public Deferred
+{
+private:
+    /**
+     *  Callback to execute when the queue is declared
+     *  @var    QueueCallback
+     */
+    QueueCallback _queueCallback;
+
+    /**
+     *  Report success for queue declared messages
+     *  @param  name            Name of the new queue
+     *  @param  messagecount    Number of messages in the queue
+     *  @param  consumercount   Number of consumers linked to the queue
+     *  @return Deferred        Next deferred result
+     */
+    virtual Deferred *reportSuccess(const std::string &name, uint32_t messagecount, uint32_t consumercount) const override
+    {
+        // skip if no special callback was installed
+        if (!_queueCallback) return Deferred::reportSuccess();
+        
+        // call the queue callback
+        _queueCallback(name, messagecount, consumercount);
+        
+        // call finalize callback
+        if (_finalizeCallback) _finalizeCallback();
+        
+        // return next object
+        return _next;
+    }
+
+    /**
+     *  The channel implementation may call our
+     *  private members and construct us
+     */
+    friend class ChannelImpl;
+    friend class ConsumedMessage;
+    
+protected:
+    /**
+     *  Protected constructor that can only be called
+     *  from within the channel implementation
+     *
+     *  @param  boolea  are we already failed?
+     */
+    DeferredQueue(bool failed = false) : Deferred(failed) {}
+
+public:
+    /**
+     *  Register a function to be called when the queue is declared
+     *
+     *  Only one callback can be registered. Successive calls
+     *  to this function will clear callbacks registered before.
+     *
+     *  @param  callback    the callback to execute
+     */
+    DeferredQueue &onSuccess(const QueueCallback &callback)
+    {
+        // store callback
+        _queueCallback = callback;
+        
+        // allow chaining
+        return *this;
+    }
+    
+    /**
+     *  All the onSuccess() functions defined in the base class are accessible too
+     */
+    using Deferred::onSuccess;
+};
+
+/**
+ *  End namespace
+ */
+}
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index a478dff..53e7438 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -85,6 +85,28 @@ ChannelImpl::~ChannelImpl()
 
     // close the channel now
     close();
+    
+    
+    // @todo destruct deferred resutls
+}
+
+/**
+ *  Push a deferred result
+ *  @param  result          The deferred object to push
+ *  @param  error           Error message in case of error
+ */
+void ChannelImpl::push(Deferred *deferred, const char *error)
+{
+    // do we already have an oldest?
+    if (!_oldestCallback) _oldestCallback = deferred;
+    
+    // do we already have a newest?
+    if (_newestCallback) _newestCallback->add(deferred);
+    
+    // store newest callback
+    _newestCallback = deferred;
+    
+    // @todo in case of error we have to report the error with a timeout
 }
 
 /**
@@ -95,10 +117,10 @@ ChannelImpl::~ChannelImpl()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::pause()
+Deferred &ChannelImpl::pause()
 {
     // send a channel flow frame
-    return send<>(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
+    return send(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
 }
 
 /**
@@ -109,10 +131,10 @@ Deferred<>& ChannelImpl::pause()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::resume()
+Deferred &ChannelImpl::resume()
 {
     // send a channel flow frame
-    return send<>(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
+    return send(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
 }
 
 /**
@@ -121,10 +143,10 @@ Deferred<>& ChannelImpl::resume()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::startTransaction()
+Deferred &ChannelImpl::startTransaction()
 {
     // send a transaction frame
-    return send<>(TransactionSelectFrame(_id), "Cannot send transaction start frame");
+    return send(TransactionSelectFrame(_id), "Cannot send transaction start frame");
 }
 
 /**
@@ -133,10 +155,10 @@ Deferred<>& ChannelImpl::startTransaction()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::commitTransaction()
+Deferred &ChannelImpl::commitTransaction()
 {
     // send a transaction frame
-    return send<>(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
+    return send(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
@@ -145,10 +167,10 @@ Deferred<>& ChannelImpl::commitTransaction()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::rollbackTransaction()
+Deferred &ChannelImpl::rollbackTransaction()
 {
     // send a transaction frame
-    return send<>(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
+    return send(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
 }
 
 /**
@@ -157,13 +179,13 @@ Deferred<>& ChannelImpl::rollbackTransaction()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::close()
+Deferred &ChannelImpl::close()
 {
     // channel could be dead after send operation, we need to monitor that
     Monitor monitor(this);
 
     // send a channel close frame
-    auto &handler = send<>(ChannelCloseFrame(_id), "Cannot send channel close frame");
+    auto &handler = send(ChannelCloseFrame(_id), "Cannot send channel close frame");
 
     // was the frame sent and are we still alive?
     if (handler && monitor.valid()) _state = state_closing;
@@ -183,7 +205,7 @@ Deferred<>& ChannelImpl::close()
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments)
+Deferred &ChannelImpl::declareExchange(const std::string &name, ExchangeType type, int flags, const Table &arguments)
 {
     // convert exchange type
     std::string exchangeType;
@@ -193,7 +215,7 @@ Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType t
     if (type == ExchangeType::headers)exchangeType = "headers";
 
     // send declare exchange frame
-    return send<>(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
+    return send(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
 }
 
 /**
@@ -208,10 +230,10 @@ Deferred<>& ChannelImpl::declareExchange(const std::string &name, ExchangeType t
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange bind frame
-    return send<>(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
+    return send(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
 }
 
 /**
@@ -226,10 +248,10 @@ Deferred<>& ChannelImpl::bindExchange(const std::string &source, const std::stri
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange unbind frame
-    return send<>(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
+    return send(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
 }
 
 /**
@@ -241,10 +263,10 @@ Deferred<>& ChannelImpl::unbindExchange(const std::string &source, const std::st
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::removeExchange(const std::string &name, int flags)
+Deferred &ChannelImpl::removeExchange(const std::string &name, int flags)
 {
     // send delete exchange frame
-    return send<>(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
+    return send(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
 }
 
 /**
@@ -256,10 +278,19 @@ Deferred<>& ChannelImpl::removeExchange(const std::string &name, int flags)
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<const std::string&, uint32_t, uint32_t>& ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
+DeferredQueue &ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
 {
+    // the frame to send
+    QueueDeclareFrame frame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments);
+    
     // send the queuedeclareframe
-    return send<const std::string&, uint32_t, uint32_t>(QueueDeclareFrame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments), "Cannot send queue declare frame");
+    auto *result = new DeferredQueue(send(frame));
+    
+    // add the deferred result
+    push(result, "Cannot send queue declare frame");
+    
+    // done
+    return *result;
 }
 
 /**
@@ -274,10 +305,10 @@ Deferred<const std::string&, uint32_t, uint32_t>& ChannelImpl::declareQueue(cons
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send the bind queue frame
-    return send<>(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
+    return send(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
 }
 
 /**
@@ -291,10 +322,10 @@ Deferred<>& ChannelImpl::bindQueue(const std::string &exchangeName, const std::s
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
+Deferred &ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
 {
     // send the unbind queue frame
-    return send<>(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
+    return send(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
 }
 
 /**
@@ -315,10 +346,19 @@ Deferred<>& ChannelImpl::unbindQueue(const std::string &exchange, const std::str
  *
  *  });
  */
-Deferred<uint32_t>& ChannelImpl::purgeQueue(const std::string &name, int flags)
+DeferredDelete &ChannelImpl::purgeQueue(const std::string &name, int flags)
 {
-    // send the queue purge frame
-    return send<uint32_t>(QueuePurgeFrame(_id, name, flags & nowait), "Cannot send queue purge frame");
+    // the frame to send 
+    QueuePurgeFrame frame(_id, name, flags & nowait);
+    
+    // send the frame, and create deferred object
+    auto *deferred = new DeferredDelete(send(frame));
+    
+    // push to list
+    push(deferred, "Cannot send queue purge frame");
+    
+    // done
+    return *deferred;
 }
 
 /**
@@ -339,10 +379,19 @@ Deferred<uint32_t>& ChannelImpl::purgeQueue(const std::string &name, int flags)
  *
  *  });
  */
-Deferred<uint32_t>& ChannelImpl::removeQueue(const std::string &name, int flags)
+DeferredDelete &ChannelImpl::removeQueue(const std::string &name, int flags)
 {
-    // send the remove queue frame
-    return send<uint32_t>(QueueDeleteFrame(_id, name, flags & ifunused, flags & ifempty, flags & nowait), "Cannot send remove queue frame");
+    // the frame to send
+    QueueDeleteFrame frame(_id, name, flags & ifunused, flags & ifempty, flags & nowait);
+
+    // send the frame, and create deferred object
+    auto *deferred = new DeferredDelete(send(frame));
+    
+    // push to list
+    push(deferred, "Cannot send remove queue frame");
+    
+    // done
+    return *deferred;
 }
 
 /**
@@ -410,7 +459,7 @@ bool ChannelImpl::publish(const std::string &exchange, const std::string &routin
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::setQos(uint16_t prefetchCount)
+Deferred &ChannelImpl::setQos(uint16_t prefetchCount)
 {
     // send a qos frame
     return send(BasicQosFrame(_id, prefetchCount, false), "Cannot send basic QOS frame");
@@ -473,10 +522,19 @@ DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::stri
  *
  *  });
  */
-Deferred<const std::string&>& ChannelImpl::cancel(const std::string &tag, int flags)
+DeferredCancel &ChannelImpl::cancel(const std::string &tag, int flags)
 {
-    // send a cancel frame
-    return send<const std::string&>(BasicCancelFrame(_id, tag, flags & nowait), "Cannot send basic cancel frame");
+    // the cancel frame to send
+    BasicCancelFrame frame(_id, tag, flags & nowait);
+
+    // send the frame, and create deferred object
+    auto *deferred = new DeferredCancel(send(frame));
+    
+    // push to list
+    push(deferred, "Cannot send basic cancel frame");
+    
+    // done
+    return *deferred;
 }
 
 /**
@@ -510,7 +568,7 @@ bool ChannelImpl::reject(uint64_t deliveryTag, int flags)
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred<>& ChannelImpl::recover(int flags)
+Deferred &ChannelImpl::recover(int flags)
 {
     // send a nack frame
     return send(BasicRecoverFrame(_id, flags & requeue), "Cannot send basic recover frame");
@@ -536,32 +594,16 @@ bool ChannelImpl::send(const Frame &frame)
  *  @param  frame       frame to send
  *  @param  message     the message to trigger if the frame cannot be send at all
  */
-template <typename... Arguments>
-Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *message)
+Deferred &ChannelImpl::send(const Frame &frame, const char *message)
 {
-    // create a new deferred handler and get a pointer to it
-    // note: cannot use auto here or the lambda below chokes
-    // when compiling under gcc 4.8
-    Deferred<Arguments...> *handler = &_callbacks.push_back(Deferred<Arguments...>());
-
-    // send the frame over the channel
-    if (!send(frame))
-    {
-        // we can immediately put the handler in failed state
-        handler->_failed = true;
-
-        // register an error on the deferred handler
-        // after a timeout, so it gets called only
-        // after a possible handler was installed.
-        _connection->_handler->setTimeout(_connection->_parent, 0, [handler, message]() {
-            
-            // emit an error on the handler
-            handler->error(message);
-        });
-    }
-
-    // return the new handler
-    return *handler;
+    // send the frame, and create deferred object
+    auto *deferred = new Deferred(send(frame));
+    
+    // push to list
+    push(deferred, message);
+    
+    // done
+    return *deferred;
 }
 
 /**
@@ -569,6 +611,8 @@ Deferred<Arguments...>& ChannelImpl::send(const Frame &frame, const char *messag
  */
 void ChannelImpl::reportMessage()
 {
+    // @todo what does this method do?
+    
     // skip if there is no message
     if (!_message) return;
 
diff --git a/src/queuedeclareokframe.h b/src/queuedeclareokframe.h
index 875ff2b..eb660d8 100644
--- a/src/queuedeclareokframe.h
+++ b/src/queuedeclareokframe.h
@@ -132,8 +132,8 @@ public:
         // what if channel doesn't exist?
         if (!channel) return false;
 
-        // report to the handler, we need to specify template arguments otherwise a string will lose const and reference
-        channel->reportSuccess<const std::string&, uint32_t, uint32_t>(this->name(), this->messageCount(), this->consumerCount());
+        // report success
+        channel->reportSuccess(name(), messageCount(), consumerCount());
 
         // done
         return true;

From 745ab512a5d4116d08fbd936d47a17e853fc9ee6 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 11:39:52 +0200
Subject: [PATCH 22/41] the consumer message callback can now also be installed
 via the Deferred objects, and it is no longer passed a consumer tag, because
 it already is obvious what the consumer tag is supposed to be

---
 include/callbacks.h        |  3 +-
 include/channelimpl.h      | 53 +++++++++++++++--------------
 include/deferredconsumer.h | 59 +++++++++++++++++++++-----------
 src/basicconsumeokframe.h  |  2 +-
 src/channelimpl.cpp        | 69 +++++++++++++++++---------------------
 src/consumedmessage.h      | 17 +++++++---
 src/deferredconsumer.cpp   | 43 ++++++++++++++++++++++++
 src/messageimpl.h          |  6 ----
 src/receivedframe.cpp      |  1 +
 src/returnedmessage.h      |  9 -----
 10 files changed, 157 insertions(+), 105 deletions(-)
 create mode 100644 src/deferredconsumer.cpp

diff --git a/include/callbacks.h b/include/callbacks.h
index 50239a0..a974ef0 100644
--- a/include/callbacks.h
+++ b/include/callbacks.h
@@ -20,9 +20,10 @@ namespace AMQP {
 using SuccessCallback   =   std::function<void()>;
 using ErrorCallback     =   std::function<void(const char *message)>;
 using FinalizeCallback  =   std::function<void()>;
-using ConsumeCallback   =   std::function<void(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered)>;
+using MessageCallback   =   std::function<void(const Message &message, uint64_t deliveryTag, bool redelivered)>;
 using QueueCallback     =   std::function<void(const std::string &name, uint32_t messagecount, uint32_t consumercount)>;
 using DeleteCallback    =   std::function<void(uint32_t deletedmessages)>;
+using ConsumeCallback   =   std::function<void(const std::string &consumer)>;
 using CancelCallback    =   std::function<void(const std::string &consumer)>;
 
 /**
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 43a87ba..8666240 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -14,6 +14,11 @@
  */
 namespace AMQP {
 
+/**
+ *  Forward declarations
+ */
+class ConsumedMessage;
+
 /**
  *  Class definition
  */
@@ -45,11 +50,10 @@ private:
     ErrorCallback _errorCallback;
 
     /**
-     *  Callback to execute when a message arrives
-     * 
-     *  @todo   do this different??
+     *  Callbacks for all consumers that are active
+     *  @var    std::map<std::string,MessageCallback>
      */
-    std::unique_ptr<DeferredConsumer> _consumer;
+    std::map<std::string,MessageCallback> _consumers;
 
     /**
      *  Pointer to the oldest deferred result (the first one that is going
@@ -84,9 +88,9 @@ private:
 
     /**
      *  The message that is now being received
-     *  @var MessageImpl
+     *  @var ConsumedMessage
      */
-    MessageImpl *_message = nullptr;
+    ConsumedMessage *_message = nullptr;
 
     /**
      *  Construct a channel object
@@ -491,6 +495,20 @@ public:
         // @todo destruct oldest callback
     }
 
+    /**
+     *  Install a consumer callback
+     *  @param  consumertag     The consumer tag
+     *  @param  callback        The callback to be called
+     */
+    void install(const std::string &consumertag, const MessageCallback &callback)
+    {
+        // install the callback if it is assigned
+        if (callback) _consumers[consumertag] = callback;
+        
+        // otherwise we erase the previously set callback
+        else _consumers.erase(consumertag);
+    }
+
     /**
      *  Report that a message was received
      */
@@ -499,34 +517,19 @@ public:
     /**
      *  Create an incoming message
      *  @param  frame
-     *  @return MessageImpl
+     *  @return ConsumedMessage
      */
-    MessageImpl *message(const BasicDeliverFrame &frame);
+    ConsumedMessage *message(const BasicDeliverFrame &frame);
 
     /**
      *  Retrieve the current incoming message
-     *  @return MessageImpl
+     *  @return ConsumedMessage
      */
-    MessageImpl *message()
+    ConsumedMessage *message()
     {
         return _message;
     }
 
-    /**
-     *  Report that the consumer has started
-     *
-     *  @param  consumerTag the tag under which we are now consuming
-     */
-    void reportConsumerStarted(const std::string& consumerTag)
-    {
-        // if we do not have a consumer, something is very wrong
-        if (!_consumer) reportError("Received basic consume ok frame, but no consumer was found");
-
-        // otherwise, we now report the consumer as started
-        // @todo look at this implementation
-        //else _consumer->success(consumerTag);
-    }
-
     /**
      *  The channel class is its friend, thus can it instantiate this object
      */
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
index c1555ad..60104d1 100644
--- a/include/deferredconsumer.h
+++ b/include/deferredconsumer.h
@@ -17,25 +17,31 @@ namespace AMQP {
 class DeferredConsumer : public Deferred
 {
 private:
+    /**
+     *  The channel to which the consumer is linked
+     *  @var    ChannelImpl
+     */
+    ChannelImpl *_channel;
+
     /**
      *  Callback to execute when a message arrives
-     *  @var    ConsumeCallbacl
+     *  @var    ConsumeCallback
      */
     ConsumeCallback _consumeCallback;
 
     /**
-     *  Process a message
-     *
-     *  @param  message the message to process
-     *  @param  deliveryTag the message delivery tag
-     *  @param  consumerTag the tag we are consuming under
-     *  @param  is this a redelivered message?
+     *  Callback for incoming messages
+     *  @var    MessageCallback
      */
-    void message(const Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) const
-    {
-        // do we have a valid callback
-        if (_consumeCallback) _consumeCallback(message, deliveryTag, consumerTag, redelivered);
-    }
+    MessageCallback _messageCallback;
+
+
+    /**
+     *  Report success for frames that report start consumer operations
+     *  @param  name            Consumer tag that is started
+     *  @return Deferred
+     */
+    virtual Deferred *reportSuccess(const std::string &name) const override;
 
     /**
      *  The channel implementation may call our
@@ -49,23 +55,36 @@ protected:
      *  Protected constructor that can only be called
      *  from within the channel implementation
      *
-     *  @param  boolea  are we already failed?
+     *  @param  channel     the channel implementation
+     *  @param  failed      are we already failed?
      */
-    DeferredConsumer(bool failed = false) : Deferred(failed) {}
+    DeferredConsumer(ChannelImpl *channel, bool failed = false) : 
+        Deferred(failed), _channel(channel) {}
 
 public:
+    /**
+     *  Register the function that is called when the consumer starts
+     *  @param  callback
+     */
+    DeferredConsumer &onSuccess(const ConsumeCallback &callback)
+    {
+        // store the callback
+        _consumeCallback = callback;
+        
+        // allow chaining
+        return *this;
+    }
+
     /**
      *  Register a function to be called when a message arrives
-     *
-     *  Only one callback can be registered. Successive calls
-     *  to this function will clear callbacks registered before.
-     *
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer& onReceived(const ConsumeCallback &callback)
+    DeferredConsumer& onReceived(const MessageCallback &callback)
     {
         // store callback
-        _consumeCallback = callback;
+        _messageCallback = callback;
+        
+        // allow chaining
         return *this;
     }
 
diff --git a/src/basicconsumeokframe.h b/src/basicconsumeokframe.h
index 1ed8ef4..31c44ef 100644
--- a/src/basicconsumeokframe.h
+++ b/src/basicconsumeokframe.h
@@ -94,7 +94,7 @@ public:
         if (!channel) return false;
 
         // report
-        channel->reportConsumerStarted(consumerTag());
+        channel->reportSuccess(consumerTag());
 
         // done
         return true;
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 53e7438..a28bf77 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -487,21 +487,17 @@ Deferred &ChannelImpl::setQos(uint16_t prefetchCount)
  */
 DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments)
 {
-    // create the deferred consumer
-    _consumer = std::unique_ptr<DeferredConsumer>(new DeferredConsumer(false));
-
-    // can we send the basic consume frame?
-    if (!send(BasicConsumeFrame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments)))
-    {
-        // we set the consumer to be failed immediately
-        _consumer->_failed = true;
-
-        // we should call the error function later
-        // TODO
-    }
-
-    // return the consumer
-    return *_consumer;
+    // the frame to send
+    BasicConsumeFrame frame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments);
+    
+    // send the frame, and create deferred object
+    auto *deferred = new DeferredConsumer(this, send(frame));
+    
+    // push to list
+    push(deferred, "Cannot send basic consume frame");
+    
+    // done
+    return *deferred;
 }
 
 /**
@@ -611,44 +607,39 @@ Deferred &ChannelImpl::send(const Frame &frame, const char *message)
  */
 void ChannelImpl::reportMessage()
 {
-    // @todo what does this method do?
-    
     // skip if there is no message
     if (!_message) return;
 
-    // do we even have a consumer?
-    if (!_consumer)
-    {
-        // this should not be possible: receiving a message without doing a consume() call
-        reportError("Received message without having a consumer");
-    }
-    else
-    {
-        // after the report the channel may be destructed, monitor that
-        Monitor monitor(this);
+    // look for the consumer
+    auto iter = _consumers.find(_message->consumer());
+    if (iter == _consumers.end()) return;
+    
+    // is this a valid callback method
+    if (!iter->second) return;
 
-        // send message to the consumer
-        _message->report(*_consumer);
-
-        // skip if channel was destructed
-        if (!monitor.valid()) return;
-    }
+    // after the report the channel may be destructed, monitor that
+    Monitor monitor(this);
+    
+    // call the callback
+    _message->report(iter->second);
+    
+    // skip if channel was destructed
+    if (!monitor.valid()) return;
 
     // no longer need the message
-    delete _message;
-    _message = nullptr;
+    delete _message; _message = nullptr;
 }
 
 /**
  *  Create an incoming message
  *  @param  frame
- *  @return MessageImpl
+ *  @return ConsumedMessage
  */
-MessageImpl *ChannelImpl::message(const BasicDeliverFrame &frame)
+ConsumedMessage *ChannelImpl::message(const BasicDeliverFrame &frame)
 {
-    // it should not be possible that a message already exists, but lets check it anyhow
+    // destruct if message is already set
     if (_message) delete _message;
-
+    
     // construct a message
     return _message = new ConsumedMessage(frame);
 }
diff --git a/src/consumedmessage.h b/src/consumedmessage.h
index 2227763..447bdc6 100644
--- a/src/consumedmessage.h
+++ b/src/consumedmessage.h
@@ -50,13 +50,22 @@ public:
     virtual ~ConsumedMessage() {}
 
     /**
-     *  Report to the handler
-     *  @param  consumer
+     *  Retrieve the consumer tag
+     *  @return std::string
      */
-    virtual void report(const DeferredConsumer& consumer) override
+    const std::string &consumer() const
+    {
+        return _consumerTag;
+    }
+     
+    /**
+     *  Report to the handler
+     *  @param  callback
+     */
+    void report(const MessageCallback &callback) const
     {
         // send ourselves to the consumer
-        consumer.message(*this, _deliveryTag, _consumerTag, _redelivered);
+        if (callback) callback(*this, _deliveryTag, _redelivered);
     }
 };
 
diff --git a/src/deferredconsumer.cpp b/src/deferredconsumer.cpp
new file mode 100644
index 0000000..eb8c6e1
--- /dev/null
+++ b/src/deferredconsumer.cpp
@@ -0,0 +1,43 @@
+/**
+ *  DeferredConsumer.cpp
+ *
+ *  Implementation file for the DeferredConsumer class
+ *
+ *  @copyright 2014 Copernica BV
+ */
+#include "includes.h"
+
+/**
+ *  Namespace
+ */
+namespace AMQP {
+
+/**
+ *  Report success for frames that report start consumer operations
+ *  @param  name            Consumer tag that is started
+ *  @return Deferred
+ */
+Deferred *DeferredConsumer::reportSuccess(const std::string &name) const
+{
+    // we now know the name, so we can install the message callback on the channel
+    _channel->install(name, _messageCallback);
+    
+    // @todo when a consumer stops, we should uninstall the message callback
+    
+    // skip if no special callback was installed
+    if (!_consumeCallback) return Deferred::reportSuccess();
+    
+    // call the callback
+    _consumeCallback(name);
+    
+    // call finalize callback
+    if (_finalizeCallback) _finalizeCallback();
+    
+    // return next object
+    return _next;
+}
+
+/**
+ *  End namespace
+ */
+}
diff --git a/src/messageimpl.h b/src/messageimpl.h
index 1b087dd..f9f839a 100644
--- a/src/messageimpl.h
+++ b/src/messageimpl.h
@@ -98,12 +98,6 @@ public:
             return _received >= _bodySize;
         }
     }
-
-    /**
-     *  Report to the handler
-     *  @param  consumer
-     */
-    virtual void report(const DeferredConsumer& consumer) = 0;
 };
 
 /**
diff --git a/src/receivedframe.cpp b/src/receivedframe.cpp
index cfe1c77..87aaba0 100644
--- a/src/receivedframe.cpp
+++ b/src/receivedframe.cpp
@@ -66,6 +66,7 @@
 #include "transactionrollbackframe.h"
 #include "transactionrollbackokframe.h"
 #include "messageimpl.h"
+#include "consumedmessage.h"
 #include "bodyframe.h"
 #include "basicheaderframe.h"
 #include "framecheck.h"
diff --git a/src/returnedmessage.h b/src/returnedmessage.h
index 322bb88..776d72d 100644
--- a/src/returnedmessage.h
+++ b/src/returnedmessage.h
@@ -45,15 +45,6 @@ public:
      *  Destructor
      */
     virtual ~ReturnedMessage() {}
-
-    /**
-     *  Report to the handler
-     *  @param  consumer
-     */
-    virtual void report(const DeferredConsumer& consumer) override
-    {
-        // we no longer support returned messages
-    }
 };
 
 /**

From 301b8153e30e1a2d76d6df19e0969bca01cf875f Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 12:25:56 +0200
Subject: [PATCH 23/41] deferred objects are now correctly destructed + added
 extra checks so that no crashes occur when someone destructs a channel inside
 a callback function

---
 amqpcpp.h                  |  1 +
 include/channelimpl.h      | 43 +++++++++++++++++++++++++++-----------
 include/deferred.h         |  9 ++++++++
 {src => include}/monitor.h |  0
 src/channelimpl.cpp        |  6 +++---
 src/includes.h             |  1 -
 6 files changed, 44 insertions(+), 16 deletions(-)
 rename {src => include}/monitor.h (100%)

diff --git a/amqpcpp.h b/amqpcpp.h
index 06f19f8..0065da6 100644
--- a/amqpcpp.h
+++ b/amqpcpp.h
@@ -34,6 +34,7 @@
 #include <amqpcpp/receivedframe.h>
 #include <amqpcpp/outbuffer.h>
 #include <amqpcpp/watchable.h>
+#include <amqpcpp/monitor.h>
 
 // amqp types
 #include <amqpcpp/field.h>
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 8666240..91d666c 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -61,7 +61,7 @@ private:
      * 
      *  @var    Deferred
      */
-    Deferred *_oldestCallback = nullptr;
+    std::unique_ptr<Deferred> _oldestCallback = nullptr;
     
     /**
      *  Pointer to the newest deferred result (the last one to be added).
@@ -464,11 +464,21 @@ public:
     {
         // skip if there is no oldest callback
         if (!_oldestCallback) return;
+     
+        // we are going to call callbacks that could destruct the channel
+        Monitor monitor(this);
+     
+        // call the callback
+        auto *next = _oldestCallback->reportSuccess(std::forward<Arguments>(parameters)...);
         
-        // report to the oldest callback, and install a new oldest callback
-        _oldestCallback = _oldestCallback->reportSuccess(std::forward<Arguments>(parameters)...);
+        // leap out if channel no longer exists
+        if (!monitor.valid()) return;
         
-        // @todo destruct oldest callback
+        // set the oldest callback
+        _oldestCallback.reset(next);
+        
+        // if there was no next callback, the newest callback was just used
+        if (!next) _newestCallback = nullptr;
     }
 
     /**
@@ -480,19 +490,28 @@ public:
         // change state
         _state = state_closed;
 
-        // @todo    multiple callbacks are called, this could break
+        // we are going to call callbacks that could destruct the channel
+        Monitor monitor(this);
+        
         // @todo    should this be a std::string parameter?
 
         // inform handler
         if (_errorCallback) _errorCallback(message.c_str());
+        
+        // leap out if channel is already destructed, or when there are no further callbacks
+        if (!monitor.valid() || !_oldestCallback) return;
 
-        // skip if there is no oldest callback
-        if (!_oldestCallback) return;
-
-        // report to the oldest callback, and install a new oldest callback
-        _oldestCallback = _oldestCallback->reportError(message);
-
-        // @todo destruct oldest callback
+        // call the callback
+        auto *next = _oldestCallback->reportError(message);
+        
+        // leap out if channel no longer exists
+        if (!monitor.valid()) return;
+        
+        // set the oldest callback
+        _oldestCallback.reset(next);
+        
+        // if there was no next callback, the newest callback was just used
+        if (!next) _newestCallback = nullptr;
     }
 
     /**
diff --git a/include/deferred.h b/include/deferred.h
index 777a370..f2e849c 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -54,6 +54,15 @@ protected:
     bool _failed;
 
 
+    /**
+     *  The next deferred object
+     *  @return Deferred
+     */
+    Deferred *next() const
+    {
+        return _next;
+    }
+
     /**
      *  Indicate success
      *  @return Deferred        Next deferred result
diff --git a/src/monitor.h b/include/monitor.h
similarity index 100%
rename from src/monitor.h
rename to include/monitor.h
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index a28bf77..8d93563 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -86,8 +86,8 @@ ChannelImpl::~ChannelImpl()
     // close the channel now
     close();
     
-    
-    // @todo destruct deferred resutls
+    // destruct deferred results
+    while (_oldestCallback) _oldestCallback.reset(_oldestCallback->next());
 }
 
 /**
@@ -98,7 +98,7 @@ ChannelImpl::~ChannelImpl()
 void ChannelImpl::push(Deferred *deferred, const char *error)
 {
     // do we already have an oldest?
-    if (!_oldestCallback) _oldestCallback = deferred;
+    if (!_oldestCallback) _oldestCallback.reset(deferred);
     
     // do we already have a newest?
     if (_newestCallback) _newestCallback->add(deferred);
diff --git a/src/includes.h b/src/includes.h
index 52b31d0..2a75192 100644
--- a/src/includes.h
+++ b/src/includes.h
@@ -11,7 +11,6 @@
 #include "../amqpcpp.h"
 
 // classes that are very commonly used
-#include "monitor.h"
 #include "exception.h"
 #include "protocolexception.h"
 #include "frame.h"

From 3b782473633145a8ab48da42bd8d81fab3f68093 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 12:29:22 +0200
Subject: [PATCH 24/41] error callbacks get a const char *, no longer a
 std::string

---
 include/channelimpl.h   |  4 ++--
 include/deferred.h      | 19 +------------------
 src/channelcloseframe.h |  2 +-
 3 files changed, 4 insertions(+), 21 deletions(-)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index 91d666c..ba0d9e4 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -485,7 +485,7 @@ public:
      *  Report an error message on a channel
      *  @param  message
      */
-    void reportError(const std::string &message)
+    void reportError(const char *message)
     {
         // change state
         _state = state_closed;
@@ -496,7 +496,7 @@ public:
         // @todo    should this be a std::string parameter?
 
         // inform handler
-        if (_errorCallback) _errorCallback(message.c_str());
+        if (_errorCallback) _errorCallback(message);
         
         // leap out if channel is already destructed, or when there are no further callbacks
         if (!monitor.valid() || !_oldestCallback) return;
diff --git a/include/deferred.h b/include/deferred.h
index f2e849c..897c36a 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -117,28 +117,11 @@ protected:
      *  @param  error           Description of the error that occured
      *  @return Deferred        Next deferred result
      */
-    Deferred *reportError(const std::string& error) 
-    {
-        // from this moment on the object should be listed as failed
-        _failed = true;
-        
-        // execute callbacks if registered
-        if (_errorCallback)     _errorCallback(error.c_str());
-        if (_finalizeCallback)  _finalizeCallback();
-        
-        // return the next deferred result
-        return _next;
-    }
-
-    /**
-     *  Indicate failure
-     *  @param  error   description of the error that occured
-     */
     Deferred *reportError(const char *error) 
     {
         // from this moment on the object should be listed as failed
         _failed = true;
-
+        
         // execute callbacks if registered
         if (_errorCallback)     _errorCallback(error);
         if (_finalizeCallback)  _finalizeCallback();
diff --git a/src/channelcloseframe.h b/src/channelcloseframe.h
index 6db745f..0d9c1d6 100644
--- a/src/channelcloseframe.h
+++ b/src/channelcloseframe.h
@@ -156,7 +156,7 @@ public:
         if (!channel) return false;
         
         // report to the handler
-        channel->reportError(text());
+        channel->reportError(_text.value().c_str());
         
         // done
         return true;

From ae7a32a8bf7c602171c510fdd0871d6dd10dbd26 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 12:36:11 +0200
Subject: [PATCH 25/41] when a consumer is cancelled, it is also removed from
 the map of active consumers in the the ChannelImpl object

---
 include/channelimpl.h    | 12 ++++++++++--
 include/deferredcancel.h | 27 +++++++++++---------------
 src/channelimpl.cpp      |  2 +-
 src/deferredcancel.cpp   | 42 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 64 insertions(+), 19 deletions(-)
 create mode 100644 src/deferredcancel.cpp

diff --git a/include/channelimpl.h b/include/channelimpl.h
index ba0d9e4..0f607bf 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -493,8 +493,6 @@ public:
         // we are going to call callbacks that could destruct the channel
         Monitor monitor(this);
         
-        // @todo    should this be a std::string parameter?
-
         // inform handler
         if (_errorCallback) _errorCallback(message);
         
@@ -528,6 +526,16 @@ public:
         else _consumers.erase(consumertag);
     }
 
+    /**
+     *  Uninstall a consumer callback
+     *  @param  consumertag     The consumer tag
+     */
+    void uninstall(const std::string &consumertag)
+    {
+        // erase the callback
+        _consumers.erase(consumertag);
+    }
+
     /**
      *  Report that a message was received
      */
diff --git a/include/deferredcancel.h b/include/deferredcancel.h
index 401716d..244e145 100644
--- a/include/deferredcancel.h
+++ b/include/deferredcancel.h
@@ -19,6 +19,12 @@ namespace AMQP {
 class DeferredCancel : public Deferred
 {
 private:
+    /**
+     *  Pointer to the channel
+     *  @var    ChannelImpl
+     */
+    ChannelImpl *_channel;
+
     /**
      *  Callback to execute when the instruction is completed
      *  @var    CancelCallback
@@ -30,20 +36,7 @@ private:
      *  @param  name            Consumer tag that is cancelled
      *  @return Deferred
      */
-    virtual Deferred *reportSuccess(const std::string &name) const override
-    {
-        // skip if no special callback was installed
-        if (!_cancelCallback) return Deferred::reportSuccess();
-        
-        // call the callback
-        _cancelCallback(name);
-        
-        // call finalize callback
-        if (_finalizeCallback) _finalizeCallback();
-        
-        // return next object
-        return _next;
-    }
+    virtual Deferred *reportSuccess(const std::string &name) const override;
 
     /**
      *  The channel implementation may call our
@@ -57,9 +50,11 @@ protected:
      *  Protected constructor that can only be called
      *  from within the channel implementation
      *
-     *  @param  boolean     are we already failed?
+     *  @param  channel     Pointer to the channel
+     *  @param  failed      Are we already failed?
      */
-    DeferredCancel(bool failed = false) : Deferred(failed) {}
+    DeferredCancel(ChannelImpl *channel, bool failed = false) : 
+        Deferred(failed), _channel(channel) {}
 
 public:
     /**
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 8d93563..aac9ce6 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -524,7 +524,7 @@ DeferredCancel &ChannelImpl::cancel(const std::string &tag, int flags)
     BasicCancelFrame frame(_id, tag, flags & nowait);
 
     // send the frame, and create deferred object
-    auto *deferred = new DeferredCancel(send(frame));
+    auto *deferred = new DeferredCancel(this, send(frame));
     
     // push to list
     push(deferred, "Cannot send basic cancel frame");
diff --git a/src/deferredcancel.cpp b/src/deferredcancel.cpp
new file mode 100644
index 0000000..aaecebe
--- /dev/null
+++ b/src/deferredcancel.cpp
@@ -0,0 +1,42 @@
+/**
+ *  DeferredCancel.cpp
+ *
+ *  Implementation file for the DeferredCancel class
+ *
+ *  @copyright 2014 Copernica BV
+ */
+#include "includes.h"
+
+/**
+ *  Namespace
+ */
+namespace AMQP {
+
+/**
+ *  Report success for frames that report cancel operations
+ *  @param  name            Consumer tag that is cancelled
+ *  @return Deferred
+ */
+Deferred *DeferredCancel::reportSuccess(const std::string &name) const
+{
+    // in the channel, we should uninstall the consumer
+    _channel->uninstall(name);
+    
+    // skip if no special callback was installed
+    if (!_cancelCallback) return Deferred::reportSuccess();
+    
+    // call the callback
+    _cancelCallback(name);
+    
+    // call finalize callback
+    if (_finalizeCallback) _finalizeCallback();
+    
+    // return next object
+    return _next;
+}
+
+/**
+ *  End namespace
+ */
+}
+

From d08270701e4aabc09f0b3637246e2eeda3e7b318 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 13:01:27 +0200
Subject: [PATCH 26/41] refactored dealing with error messages

---
 include/channelimpl.h       | 28 ++++++++------
 include/connectionhandler.h |  7 ++--
 src/channelimpl.cpp         | 77 ++++++++++++++++---------------------
 src/deferredconsumer.cpp    |  2 -
 4 files changed, 54 insertions(+), 60 deletions(-)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index 0f607bf..62cc70d 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -107,9 +107,16 @@ private:
     /**
      *  Push a deferred result
      *  @param  result          The deferred result
-     *  @param  error           Error message in case the result is not ok
+     *  @return Deferred        The object just pushed
      */
-    void push(Deferred *deferred, const char *error);
+    Deferred &push(Deferred *deferred);
+
+    /**
+     *  Send a framen and push a deferred result
+     *  @param  frame           The frame to send
+     *  @return Deferred        The object just pushed
+     */
+    Deferred &push(const Frame &frame);
 
 
 public:
@@ -422,18 +429,10 @@ public:
      */
     bool send(const Frame &frame);
 
-    /**
-     *  Send a frame over the channel and
-     *  get a deferred handler for it.
-     *
-     *  @param  frame       frame to send
-     *  @param  message     the message to trigger if the frame cannot be send at all
-     *  @return Deferred    the deferred object
-     */
-    Deferred &send(const Frame &frame, const char *message);
-
     /**
      *  Report to the handler that the channel is opened
+     * 
+     *  @todo when is this sent?
      */
     void reportReady()
     {
@@ -443,6 +442,8 @@ public:
 
     /**
      *  Report to the handler that the channel is closed
+     * 
+     *  @todo do we need this?
      */
     void reportClosed()
     {
@@ -450,6 +451,9 @@ public:
         _state = state_closed;
 
         // inform handler
+        
+        // @todo do we report success here?
+        
         reportSuccess();
     }
 
diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 2ffe23b..220e2dc 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -55,7 +55,7 @@ public:
      *  state and can no longer be used.
      *
      *  This method has an empty default implementation, although you are very
-     *  much advised to implement it. Because when an error occurs, the connection
+     *  much advised to implement it. When an error occurs, the connection
      *  is no longer usable, so you probably want to know.
      *
      *  @param  connection      The connection that entered the error state
@@ -65,14 +65,15 @@ public:
 
     /**
      *  Method that is called when the login attempt succeeded. After this method
-     *  was called, the connection is ready to use. This is the first method
+     *  is called, the connection is ready to use. This is the first method
      *  that is normally called after you've constructed the connection object.
      *
      *  According to the AMQP protocol, you must wait for the connection to become
      *  ready (and this onConnected method to be called) before you can start
      *  using the Connection object. However, this AMQP library will cache all
      *  methods that you call before the connection is ready, so in reality there
-     *  is no real reason to wait.
+     *  is no real reason to wait for this method to be called before you send
+     *  the first instructions.
      *
      *  @param  connection      The connection that can now be used
      */
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index aac9ce6..a3cc37e 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -93,9 +93,8 @@ ChannelImpl::~ChannelImpl()
 /**
  *  Push a deferred result
  *  @param  result          The deferred object to push
- *  @param  error           Error message in case of error
  */
-void ChannelImpl::push(Deferred *deferred, const char *error)
+Deferred &ChannelImpl::push(Deferred *deferred)
 {
     // do we already have an oldest?
     if (!_oldestCallback) _oldestCallback.reset(deferred);
@@ -107,6 +106,19 @@ void ChannelImpl::push(Deferred *deferred, const char *error)
     _newestCallback = deferred;
     
     // @todo in case of error we have to report the error with a timeout
+    
+    // done
+    return *deferred;
+}
+
+/**
+ *  Send a frame and push a deferred result
+ *  @param  frame           The frame to send
+ */
+Deferred &ChannelImpl::push(const Frame &frame)
+{
+    // send the frame, and push the result
+    return push(new Deferred(send(frame)));
 }
 
 /**
@@ -120,7 +132,7 @@ void ChannelImpl::push(Deferred *deferred, const char *error)
 Deferred &ChannelImpl::pause()
 {
     // send a channel flow frame
-    return send(ChannelFlowFrame(_id, false), "Cannot send channel flow frame");
+    return push(ChannelFlowFrame(_id, false));
 }
 
 /**
@@ -134,7 +146,7 @@ Deferred &ChannelImpl::pause()
 Deferred &ChannelImpl::resume()
 {
     // send a channel flow frame
-    return send(ChannelFlowFrame(_id, true), "Cannot send channel flow frame");
+    return push(ChannelFlowFrame(_id, true));
 }
 
 /**
@@ -146,7 +158,7 @@ Deferred &ChannelImpl::resume()
 Deferred &ChannelImpl::startTransaction()
 {
     // send a transaction frame
-    return send(TransactionSelectFrame(_id), "Cannot send transaction start frame");
+    return push(TransactionSelectFrame(_id));
 }
 
 /**
@@ -158,7 +170,7 @@ Deferred &ChannelImpl::startTransaction()
 Deferred &ChannelImpl::commitTransaction()
 {
     // send a transaction frame
-    return send(TransactionCommitFrame(_id), "Cannot send transaction commit frame");
+    return push(TransactionCommitFrame(_id));
 }
 
 /**
@@ -170,7 +182,7 @@ Deferred &ChannelImpl::commitTransaction()
 Deferred &ChannelImpl::rollbackTransaction()
 {
     // send a transaction frame
-    return send(TransactionRollbackFrame(_id), "Cannot send transaction commit frame");
+    return push(TransactionRollbackFrame(_id));
 }
 
 /**
@@ -181,14 +193,11 @@ Deferred &ChannelImpl::rollbackTransaction()
  */
 Deferred &ChannelImpl::close()
 {
-    // channel could be dead after send operation, we need to monitor that
-    Monitor monitor(this);
-
     // send a channel close frame
-    auto &handler = send(ChannelCloseFrame(_id), "Cannot send channel close frame");
+    auto &handler = push(ChannelCloseFrame(_id));
 
     // was the frame sent and are we still alive?
-    if (handler && monitor.valid()) _state = state_closing;
+    if (handler) _state = state_closing;
 
     // done
     return handler;
@@ -215,7 +224,7 @@ Deferred &ChannelImpl::declareExchange(const std::string &name, ExchangeType typ
     if (type == ExchangeType::headers)exchangeType = "headers";
 
     // send declare exchange frame
-    return send(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments), "Cannot send exchange declare frame");
+    return push(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments));
 }
 
 /**
@@ -233,7 +242,7 @@ Deferred &ChannelImpl::declareExchange(const std::string &name, ExchangeType typ
 Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange bind frame
-    return send(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange bind frame");
+    return push(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments));
 }
 
 /**
@@ -251,7 +260,7 @@ Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string
 Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send exchange unbind frame
-    return send(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments), "Cannot send exchange unbind frame");
+    return push(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments));
 }
 
 /**
@@ -266,7 +275,7 @@ Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::stri
 Deferred &ChannelImpl::removeExchange(const std::string &name, int flags)
 {
     // send delete exchange frame
-    return send(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait), "Cannot send exchange delete frame");
+    return push(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait));
 }
 
 /**
@@ -287,7 +296,7 @@ DeferredQueue &ChannelImpl::declareQueue(const std::string &name, int flags, con
     auto *result = new DeferredQueue(send(frame));
     
     // add the deferred result
-    push(result, "Cannot send queue declare frame");
+    push(result);
     
     // done
     return *result;
@@ -308,7 +317,7 @@ DeferredQueue &ChannelImpl::declareQueue(const std::string &name, int flags, con
 Deferred &ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
 {
     // send the bind queue frame
-    return send(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments), "Cannot send queue bind frame");
+    return push(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments));
 }
 
 /**
@@ -325,7 +334,7 @@ Deferred &ChannelImpl::bindQueue(const std::string &exchangeName, const std::str
 Deferred &ChannelImpl::unbindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments)
 {
     // send the unbind queue frame
-    return send(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments), "Cannot send queue unbind frame");
+    return push(QueueUnbindFrame(_id, queue, exchange, routingkey, arguments));
 }
 
 /**
@@ -355,7 +364,7 @@ DeferredDelete &ChannelImpl::purgeQueue(const std::string &name, int flags)
     auto *deferred = new DeferredDelete(send(frame));
     
     // push to list
-    push(deferred, "Cannot send queue purge frame");
+    push(deferred);
     
     // done
     return *deferred;
@@ -388,7 +397,7 @@ DeferredDelete &ChannelImpl::removeQueue(const std::string &name, int flags)
     auto *deferred = new DeferredDelete(send(frame));
     
     // push to list
-    push(deferred, "Cannot send remove queue frame");
+    push(deferred);
     
     // done
     return *deferred;
@@ -462,7 +471,7 @@ bool ChannelImpl::publish(const std::string &exchange, const std::string &routin
 Deferred &ChannelImpl::setQos(uint16_t prefetchCount)
 {
     // send a qos frame
-    return send(BasicQosFrame(_id, prefetchCount, false), "Cannot send basic QOS frame");
+    return push(BasicQosFrame(_id, prefetchCount, false));
 }
 
 /**
@@ -494,7 +503,7 @@ DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::stri
     auto *deferred = new DeferredConsumer(this, send(frame));
     
     // push to list
-    push(deferred, "Cannot send basic consume frame");
+    push(deferred);
     
     // done
     return *deferred;
@@ -527,7 +536,7 @@ DeferredCancel &ChannelImpl::cancel(const std::string &tag, int flags)
     auto *deferred = new DeferredCancel(this, send(frame));
     
     // push to list
-    push(deferred, "Cannot send basic cancel frame");
+    push(deferred);
     
     // done
     return *deferred;
@@ -567,7 +576,7 @@ bool ChannelImpl::reject(uint64_t deliveryTag, int flags)
 Deferred &ChannelImpl::recover(int flags)
 {
     // send a nack frame
-    return send(BasicRecoverFrame(_id, flags & requeue), "Cannot send basic recover frame");
+    return push(BasicRecoverFrame(_id, flags & requeue));
 }
 
 /**
@@ -584,24 +593,6 @@ bool ChannelImpl::send(const Frame &frame)
     return _connection->send(frame);
 }
 
-/**
- *  Send a frame over the channel and get a deferred handler for it.
- *
- *  @param  frame       frame to send
- *  @param  message     the message to trigger if the frame cannot be send at all
- */
-Deferred &ChannelImpl::send(const Frame &frame, const char *message)
-{
-    // send the frame, and create deferred object
-    auto *deferred = new Deferred(send(frame));
-    
-    // push to list
-    push(deferred, message);
-    
-    // done
-    return *deferred;
-}
-
 /**
  *  Report the received message
  */
diff --git a/src/deferredconsumer.cpp b/src/deferredconsumer.cpp
index eb8c6e1..528cbcb 100644
--- a/src/deferredconsumer.cpp
+++ b/src/deferredconsumer.cpp
@@ -22,8 +22,6 @@ Deferred *DeferredConsumer::reportSuccess(const std::string &name) const
     // we now know the name, so we can install the message callback on the channel
     _channel->install(name, _messageCallback);
     
-    // @todo when a consumer stops, we should uninstall the message callback
-    
     // skip if no special callback was installed
     if (!_consumeCallback) return Deferred::reportSuccess();
     

From 60b59524e7a8b44dab94d69b239d67362f3dbb3d Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 13:14:16 +0200
Subject: [PATCH 27/41] when an error is detected on a channel, all subsequent
 and cached deferred objects are notified about the error too

---
 include/channelimpl.h       |  9 +++++++++
 include/connectionhandler.h |  3 +++
 src/channelimpl.cpp         | 26 ++++++++++++++++++++++++++
 3 files changed, 38 insertions(+)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index 62cc70d..3d77fc2 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -485,6 +485,12 @@ public:
         if (!next) _newestCallback = nullptr;
     }
 
+    /**
+     *  Report errors to all deferred objects already in an error state
+     *  @param  force           Report errors even for objects not already in error state
+     */
+    void reportErrors(bool force = false);
+
     /**
      *  Report an error message on a channel
      *  @param  message
@@ -514,6 +520,9 @@ public:
         
         // if there was no next callback, the newest callback was just used
         if (!next) _newestCallback = nullptr;
+        
+        // when one error occured, all subsequent messages are in an error state too
+        reportErrors(true);
     }
 
     /**
diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 220e2dc..0fa28ee 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -31,6 +31,9 @@ public:
      *  @param  connection      the connection that needs the timeout
      *  @param  timeout         number of seconds to wait
      *  @param  callback        function to execute once time runs out
+     * 
+     * 
+     *  @todo   this one should be removed
      */
     virtual void setTimeout(Connection *connection, double seconds, const std::function<void()>& callback) {}
 
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index a3cc37e..27c1bea 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -121,6 +121,32 @@ Deferred &ChannelImpl::push(const Frame &frame)
     return push(new Deferred(send(frame)));
 }
 
+/**
+ *  Report errors to all deferred objects already in an error state
+ *  @param  force           Report errors even for objects not already in error state
+ */
+void ChannelImpl::reportErrors(bool force)
+{
+    // keep looping for as long as the oldest callback is in an error state
+    while (_oldestCallback && (force || !*_oldestCallback))
+    {
+        // construct monitor, because channel could be destructed
+        Monitor monitor(this);
+        
+        // report the error
+        auto *next = _oldestCallback->reportError("Frame could not be sent");
+        
+        // leap out if object is no longer valid after the callback was called
+        if (!monitor.valid()) return;
+        
+        // install the next deferred object
+        _oldestCallback.reset(next);
+        
+        // was this also the newest callback
+        if (!next) _newestCallback = nullptr;
+    }
+}
+
 /**
  *  Pause deliveries on a channel
  *

From b13398b09dcd64b32cdde09ed61a1ecc7a10e5a9 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 13:18:32 +0200
Subject: [PATCH 28/41] setTimeout function removed from connection handler,
 the finalize and error callbacks are called right away if installed on an
 object that already is in an error state

---
 include/connectionhandler.h | 16 ----------------
 include/deferred.h          |  6 ++++++
 src/channelimpl.cpp         |  2 +-
 3 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 0fa28ee..59c551e 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -21,22 +21,6 @@ namespace AMQP {
 class ConnectionHandler
 {
 public:
-    /**
-     *  Set a function to be executed after a given timeout.
-     *
-     *  This function is not strictly necessary to implement. If you
-     *  do not implement it, certain methods that fail immediately
-     *  will not be reported.
-     *
-     *  @param  connection      the connection that needs the timeout
-     *  @param  timeout         number of seconds to wait
-     *  @param  callback        function to execute once time runs out
-     * 
-     * 
-     *  @todo   this one should be removed
-     */
-    virtual void setTimeout(Connection *connection, double seconds, const std::function<void()>& callback) {}
-
     /**
      *  Method that is called when data needs to be sent over the network
      *
diff --git a/include/deferred.h b/include/deferred.h
index 897c36a..d8fd257 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -205,6 +205,9 @@ public:
     {
         // store callback
         _errorCallback = callback;
+
+        // if the object is already in a failed state, we call the callback right away
+        if (_failed) callback("Frame could not be sent");
         
         // allow chaining
         return *this;
@@ -230,6 +233,9 @@ public:
         // store callback
         _finalizeCallback = callback;
         
+        // if the object is already in a failed state, we call the callback right away
+        if (_failed) callback();
+        
         // allow chaining
         return *this;
     }
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 27c1bea..31cbec1 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -134,7 +134,7 @@ void ChannelImpl::reportErrors(bool force)
         Monitor monitor(this);
         
         // report the error
-        auto *next = _oldestCallback->reportError("Frame could not be sent");
+        auto *next = _oldestCallback->reportError("Frame could not be delivered");
         
         // leap out if object is no longer valid after the callback was called
         if (!monitor.valid()) return;

From 3d4a1b865e7799d7c0ba0c43649a10cb20831fa8 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 13:22:06 +0200
Subject: [PATCH 29/41] removed some @todo tags

---
 include/channelimpl.h | 10 ++--------
 src/channelimpl.cpp   |  2 --
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index 3d77fc2..21ee2af 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -431,8 +431,6 @@ public:
 
     /**
      *  Report to the handler that the channel is opened
-     * 
-     *  @todo when is this sent?
      */
     void reportReady()
     {
@@ -442,18 +440,14 @@ public:
 
     /**
      *  Report to the handler that the channel is closed
-     * 
-     *  @todo do we need this?
      */
     void reportClosed()
     {
         // change state
         _state = state_closed;
 
-        // inform handler
-        
-        // @todo do we report success here?
-        
+        // and pass on to the reportSuccess() method which will call the
+        // appropriate deferred object to report the successful operation
         reportSuccess();
     }
 
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 31cbec1..f699692 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -105,8 +105,6 @@ Deferred &ChannelImpl::push(Deferred *deferred)
     // store newest callback
     _newestCallback = deferred;
     
-    // @todo in case of error we have to report the error with a timeout
-    
     // done
     return *deferred;
 }

From 82249ee368adad8a2093aead5067cfb09d31d129 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 14:22:30 +0200
Subject: [PATCH 30/41] update documentation, error callbacks now get a const
 char * instead of a std::string

---
 README.md                   | 385 +++++++++++++++++++++++++-----------
 include/connectionhandler.h |   2 +-
 include/connectionimpl.h    |   2 +-
 src/connectioncloseframe.h  |   2 +-
 4 files changed, 271 insertions(+), 120 deletions(-)

diff --git a/README.md b/README.md
index ce5468d..81de738 100644
--- a/README.md
+++ b/README.md
@@ -77,13 +77,24 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
      *  @param  connection      The connection on which the error occured
      *  @param  message         A human readable error message
      */
-    virtual void onError(AMQP::Connection *connection, const std::string &message)
+    virtual void onError(AMQP::Connection *connection, const char *message)
     {
         // @todo
         //  add your own implementation, for example by reporting the error
         //  to the user of your program, log the error, and destruct the
         //  connection object because it is no longer in a usable state
     }
+
+    /**
+     *  Method that is called when the connection was closed. This is the 
+     *  counter part of a call to Connection::close() and it confirms that the 
+     *  connection was correctly closed.
+     *
+     *  @param  connection      The connection that was closed and that is now unusable
+     */
+    virtual void onClosed(AMQP::Connection *connection) {}
+
+
 };
 ````
 After you've implemented the ConnectionHandler class, you can start using
@@ -132,13 +143,13 @@ every time that it wants to send out data. We've explained that it is up to you
 implement that method. But what about data in the other direction? How does the
 library receive data back from RabbitMQ?
 
-As we've explained above, the AMQP-CPP library does not do any IO by itself
-and it is therefore of course also not possible for the library to receive data from
-a socket. It is again up to you to do this. If, for example, you notice in your
-event loop that the socket that is connected with the RabbitMQ server becomes
-readable, you should read out that data (for example by using the recv() system
-call), and pass the received bytes to the AMQP-CPP library. This is done by
-calling the parse() method in the Connection object.
+The AMQP-CPP library does not do any IO by itself and it is therefore of course 
+also not possible for the library to receive data from a socket. It is again up 
+to you to do this. If, for example, you notice in your event loop that the socket 
+that is connected with the RabbitMQ server becomes readable, you should read out 
+that socket (for example by using the recv() system call), and pass the received 
+bytes to the AMQP-CPP library. This is done by calling the parse() method in the 
+Connection object.
 
 The Connection::parse() method gets two parameters, a pointer to a buffer of
 data received from RabbitMQ, and a parameter that holds the size of this buffer.
@@ -149,13 +160,13 @@ The code snippet below comes from the Connection.h C++ header file.
  *  Parse data that was recevied from RabbitMQ
  *
  *  Every time that data comes in from RabbitMQ, you should call this method to parse
- *  the incoming data, and let it handle by the AMQP-CPP library. This method returns the number
- *  of bytes that were processed.
+ *  the incoming data, and let it handle by the AMQP-CPP library. This method returns 
+ *  the number of bytes that were processed.
  *
- *  If not all bytes could be processed because it only contained a partial frame, you should
- *  call this same method later on when more data is available. The AMQP-CPP library does not do
- *  any buffering, so it is up to the caller to ensure that the old data is also passed in that
- *  later call.
+ *  If not all bytes could be processed because it only contained a partial frame, 
+ *  you should call this same method later on when more data is available. The 
+ *  AMQP-CPP library does not do any buffering, so it is up to the caller to ensure 
+ *  that the old data is also passed in that later call.
  *
  *  @param  buffer      buffer to decode
  *  @param  size        size of the buffer to decode
@@ -167,12 +178,20 @@ size_t parse(char *buffer, size_t size)
 }
 ````
 
+You should do all the book keeping for the buffer yourselves. If you for example 
+call the Connection::parse() method with a buffer of 100 bytes, and the method 
+returns that only 60 bytes were processed, you should later call the method again, 
+with a buffer filled with the remaining 40 bytes. If the method returns 0, you should 
+make a new call to parse() when more data is available, with a buffer with more
+data.
+
+
 CHANNELS
 ========
 
-In the example you saw that we created a channel object. A channel is a virtual
-connection over a single TCP connection, and it is possible to create many channels
-that all use the same TCP connection.
+In the example we created a channel object. A channel is a virtual connection over 
+a single TCP connection, and it is possible to create many channels that all use 
+the same TCP connection.
 
 AMQP instructions are always sent over a channel, so before you can send the first
 command to the RabbitMQ server, you first need a channel object. The channel
@@ -183,30 +202,100 @@ C++ header file for a list of all available methods. Every method in it is well
 documented.
 
 The constructor of the Channel object accepts one parameter: the connection object.
-Unlike the connection it does not accept a handler. Instead of this (almost) every
-function in the channel returns a Deferred object. This deferred object can be used
-to install handlers to be called in case of success, failure or in either case.
+Unlike the connection it does not accept a handler. Instead of a handler object,
+(almost) every method of the Channel class returns an instance of the 'Deferred' 
+class. This object can be used to install handlers that will be called in case 
+of success or failure.
 
-For example, if you call the channel.declareQueue() method, the AMQP-CPP library will
-send a message to the RabbitMQ message broker to ask it to declare the
+For example, if you call the channel.declareExchange() method, the AMQP-CPP library 
+will send a message to the RabbitMQ message broker to ask it to declare the
 queue. However, because all operations in the library are asynchronous, the
-declareQueue() method immediately returns 'true', although it is at that time
-not yet known whether the queue was correctly declared. Only after a while,
-after the instruction has reached the server, and the confirmation from the server
-has been sent back to the client, your handler method will be called to inform
-you that the operation was succesful.
+declareExchange() method can not return 'true' or 'false' to inform you whether
+the operation was succesful or not. Only after a while, after the instruction 
+has reached the RabbitMQ server, and the confirmation from the server has been 
+sent back to the client, the library can report the result of the declareExchange()
+call.
+
+To prevent any blocking calls, the channel.declareExchange() method returns a 
+'Deferred' result object, on which you can set callback functions that will be 
+called when the operation succeeds or fails.
 
 ````c++
+// create a channel
 Channel myChannel(&connection);
-myChannel.declareQueue("my-queue")
-.onSuccess([](AMQP::Channel *channel, const std::string& name, uint32_t messageCount, uint32_t consumerCount) {
-    // by now the queue is created
-})
-.onError([](AMQP::Channel *channel, const std::string message) {
-    // something went wrong creating the channel
+
+// declare an exchange, and install callbacks for success and failure
+myChannel.declareExchange("my-exchange")
+
+    .onSuccess([]() {
+        // by now the exchange is created
+    })
+
+    .onError([](const char *message) {
+        // something went wrong creating the exchange
+    });
+````
+
+As you can see in the above example, we call the declareExchange() method, and
+treat its return value as an object, on which we immediately install a lambda
+callback function to handle success, and to handle failure.
+
+Installing the callback methods is optional. If you're not interested in the
+result of an operation, you do not have to install a callback for it. Next
+to the onSuccess() and onError() callbacks that can be installed, you can also
+install a onFinalize() method that gets called directly after the onSuccess()
+and onError() methods, and that can be used to set a callback that should
+run in either case: when the operation succeeds or when it fails.
+
+The signature for the onError() method is always the same: it gets one parameter
+with a human readable error message. The onSuccess() function has a different
+signature depending on the method that you call. Most onSuccess() functions 
+(like the one we showed for the declareExchange() method) do not get any 
+parameters at all. Some specific onSuccess callbacks receive extra parameters 
+with additional information.
+
+
+CHANNEL CALLBACKS
+=================
+
+As explained, most channel methods return a 'Deferred' object on which you can
+install callbacks using the Deferred::onError() and Deferred::onSuccess() methods.
+
+The callbacks that you install on a Deferred object, only apply to one specific
+operation. If you want to install a generic error callback for the entire channel,
+you can so so by using the Channel::onError() method. Next to the Channel::onError()
+method, you can also install a callback to be notified when the channel is ready
+for sending the first instruction to RabbitMQ.
+
+````c++
+// create a channel
+Channel myChannel(connection, &myHandler);
+
+// install a generic channel-error handler that will be called for every
+// error that occurs on the channel
+myChannel.onError([](const char *message) {
+
+    // report error
+    std::cout << "channel error: " << message << std::endl;
+});
+
+// install a generic callback that will be called when the channel is ready
+// for sending the first instruction
+myChannel.onReady([]() {
+
+    // send the first instructions (like publishing messages)
 });
 ````
 
+In theory, you should always use the onReady() function before you send any
+other instructions over the channel. In practive however, the AMQP library
+caches all instructions that were sent too early, so that you can use the
+channel object right after it was constructed.
+
+
+CHANNEL ERRORS
+==============
+
 It is important to realize that any error that occurs on a channel, will
 invalidate the entire channel,. including all subsequent instructions that
 were already sent over it. This means that if you call multiple methods in a row,
@@ -218,10 +307,11 @@ myChannel.declareQueue("my-queue");
 myChannel.declareExchange("my-exchange");
 ````
 
-If the first declareQueue() call fails in the example above, your Deferred::onError()
-method will be called after a while to report this failure. And although the
-second instruction to declare an exchange has already been sent to the server, it will be
-ignored because the channel was already in an invalid state after the first failure.
+If the first declareQueue() call fails in the example above, the second 
+myChannel.declareExchange() method will not be executed, even when this
+second instruction was already sent to the server. The second instruction will be
+ignored by the RabbitMQ server because the channel was already in an invalid 
+state after the first failure.
 
 You can overcome this by using multiple channels:
 
@@ -232,12 +322,12 @@ channel1.declareQueue("my-queue");
 channel2.declareExchange("my-exchange");
 ````
 
-Now, if an error occurs with declaring the queue, it will not have
-consequences for the other call. But this comes at a small price:
-setting up the extra channel requires and extra instruction to be sent to the
-RabbitMQ server, so some extra bytes are sent over the network,
-and some additional resources in both the client application and the
-RabbitMQ server are used (although this is all very limited).
+Now, if an error occurs with declaring the queue, it will not have consequences 
+for the other call. But this comes at a small price: setting up the extra channel 
+requires and extra instruction to be sent to the RabbitMQ server, so some extra 
+bytes are sent over the network, and some additional resources in both the client 
+application and the RabbitMQ server are used (although this is all very limited).
+
 
 FLAGS AND TABLES
 ================
@@ -265,23 +355,40 @@ tables are used by many methods.
  *  @param  flags       combination of flags
  *  @param  arguments   optional arguments
  */
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags, const Table &arguments);
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, const Table &arguments);
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const std::string &name, int flags = 0);
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags, const Table &arguments);
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(const Table &arguments);
-Deferred<const std::string&, uint32_t, uint32_t>& declareQueue(int flags = 0);
+DeferredQueue &declareQueue(const std::string &name, int flags, const Table &arguments);
+DeferredQueue &declareQueue(const std::string &name, const Table &arguments);
+DeferredQueue &declareQueue(const std::string &name, int flags = 0);
+DeferredQueue &declareQueue(int flags, const Table &arguments);
+DeferredQueue &declareQueue(const Table &arguments);
+DeferredQueue &declareQueue(int flags = 0);
 ````
 
 As you can see, the method comes in many forms, and it is up to you to choose
 the one that is most appropriate. We now take a look at the most complete
 one, the method with three parameters.
 
-Many methods in the Channel class accept an integer parameter named 'flags'.
-This is a variable in which you can set a number of options, by summing up
-all the options that are described in the documentation. If you for example
-want to create a durable, auto-deleted queue, you can pass in the value
-AMQP::durable + AMQP::autodelete.
+All above methods returns a 'DeferredQueue' object. The DeferredQueue class
+extends from the AMQP::Deferred class and allows you to install a more powerful
+onSuccess() callback function. The 'onSuccess' method for the declareQueue()
+function gets three arguments:
+
+````c++
+// create a custom callback
+auto callback = [](const std::string &name, int msgcount, int consumercount) {
+
+    // @todo add your own implementation
+
+}
+
+// declare the queue, and install the callback that is called on success
+channel.declareQueue("myQueue").onSuccess(callback);
+````
+
+Just like many others methods in the Channel class, the declareQueue() method
+accept an integer parameter named 'flags'. This is a variable in which you can 
+set method-specific options, by summing up all the options that are described in 
+the documentation above the method. If you for example want to create a durable, 
+auto-deleted queue, you can pass in the value AMQP::durable + AMQP::autodelete.
 
 The declareQueue() method also accepts a parameter named 'arguments', which is of type
 Table. This Table object can be used as an associative array to send additional
@@ -314,8 +421,8 @@ exchange to publish to, the routing key to use, and the actual message that
 you're publishing - all these parameters are standard C++ strings.
 
 More extended versions of the publish() method exist that accept additional
-arguments, and that enable you to publish entire Envelope objects, which are
-objects that contain the message plus a list of optional meta information like
+arguments, and that enable you to publish entire Envelope objects. An envelope 
+is an object that contains the message plus a list of optional meta information like
 the content-type, content-encoding, priority, expire time and more. None of these
 meta fields are interpreted by this library, and also the RabbitMQ ignores most
 of them, but the AMQP protocol defines them, and they are free for you to use.
@@ -334,8 +441,11 @@ in almost any form:
  *
  *  The following flags can be used
  *
- *      -   mandatory   if set, an unroutable message will be reported to the channel handler with the onReturned method
- *      -   immediate   if set, a message that could not immediately be consumed is returned to the onReturned method
+ *      -   mandatory   if set, an unroutable message will be reported to the 
+ *                      channel handler with the onReturned method
+ * 
+ *      -   immediate   if set, a message that could not immediately be consumed 
+ *                      is returned to the onReturned method
  *
  *  If either of the two flags is set, and the message could not immediately
  *  be published, the message is returned by the server to the client. If you
@@ -357,28 +467,39 @@ bool publish(const std::string &exchange, const std::string &routingKey, int fla
 bool publish(const std::string &exchange, const std::string &routingKey, const char *message, size_t size);
 ````
 
-Published messages are normally not confirmed by the server, therefore the publish method does not
-return a deferred. That's by design in the AMQP protocol, to not unnecessarily slow down message
-publishing. As long as no error is reported via the ChannelHandler::onError() method, you can safely
+Published messages are normally not confirmed by the server, and the RabbitMQ
+will not send a report back to inform us whether the message was succesfully
+published or not. Therefore the publish method does also not return a Deferred 
+object.
+
+As long as no error is reported via the Channel::onError() method, you can safely 
 assume that your messages were delivered.
 
-This can of course be a problem when you are publishing many messages. If you get an error halfway through
-there is no way to know for sure how many messages made it to the broker and how many should be republished.
-If this is important, you can wrap the publish commands inside a transaction. In this case, if an error occurs,
-the transaction is automatically rolled back by RabbitMQ and none of the messages are actually published.
+This can of course be a problem when you are publishing many messages. If you get 
+an error halfway through there is no way to know for sure how many messages made 
+it to the broker and how many should be republished. If this is important, you can 
+wrap the publish commands inside a transaction. In this case, if an error occurs,
+the transaction is automatically rolled back by RabbitMQ and none of the messages 
+are actually published.
 
 ````c++
+// start a transaction
 channel.startTransaction();
+
+// publish a number of messages
 channel.publish("my-exchange", "my-key", "my first message");
 channel.publish("my-exchange", "my-key", "another message");
+
+// commit the transactions, and set up callbacks that are called when
+// the transaction was successful or not
 channel.commitTransaction()
-.onSuccess([](AMQP::Channel *channel) {
-    // all messages were successfully published
-})
-.onError([](AMQP::Channel *channel) {
-    // none of the messages were published
-    // now we have to do it all over again
-});
+    .onSuccess([]() {
+        // all messages were successfully published
+    })
+    .onError([]() {
+        // none of the messages were published
+        // now we have to do it all over again
+    });
 ````
 
 
@@ -393,9 +514,8 @@ Just like the publish() method that we just described, the consume() method also
 comes in many forms. The first parameter is always the name of the queue you like
 to consume from. The subsequent parameters are an optional consumer tag, flags and
 a table with custom arguments. The first additional parameter, the consumer tag,
-is nothing more than a string identifier that will be passed with every consumed message.
-This can be useful if you call the consume() methods a number of times to consume
-from multiple queues, and you would like to know from which consume call the received messages came.
+is nothing more than a string identifier that you can use when you want to stop
+consuming.
 
 The full documentation from the C++ Channel.h headerfile looks like this:
 
@@ -411,10 +531,17 @@ The full documentation from the C++ Channel.h headerfile looks like this:
  *
  *  The following flags are supported:
  *
- *      -   nolocal             if set, messages published on this channel are not also consumed
- *      -   noack               if set, consumed messages do not have to be acked, this happens automatically
- *      -   exclusive           request exclusive access, only this consumer can access the queue
- *      -   nowait              the server does not have to send a response back that consuming is active
+ *      -   nolocal             if set, messages published on this channel are 
+ *                              not also consumed
+ *
+ *      -   noack               if set, consumed messages do not have to be acked, 
+ *                              this happens automatically
+ *
+ *      -   exclusive           request exclusive access, only this consumer can 
+ *                              access the queue
+ *
+ *      -   nowait              the server does not have to send a response back 
+ *                              that consuming is active
  *
  *  The method ChannelHandler::onConsumerStarted() will be called when the
  *  consumer has started (unless the nowait option was set, in which case
@@ -426,58 +553,82 @@ The full documentation from the C++ Channel.h headerfile looks like this:
  *  @param  arguments           additional arguments
  *  @return bool
  */
-DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags, const AMQP::Table &arguments);
-DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags = 0);
-DeferredConsumer& consume(const std::string &queue, const std::string &tag, const AMQP::Table &arguments);
-DeferredConsumer& consume(const std::string &queue, int flags, const AMQP::Table &arguments);
-DeferredConsumer& consume(const std::string &queue, int flags = 0);
-DeferredConsumer& consume(const std::string &queue, const AMQP::Table &arguments);
+DeferredConsumer &consume(const std::string &queue, const std::string &tag, int flags, const AMQP::Table &arguments);
+DeferredConsumer &consume(const std::string &queue, const std::string &tag, int flags = 0);
+DeferredConsumer &consume(const std::string &queue, const std::string &tag, const AMQP::Table &arguments);
+DeferredConsumer &consume(const std::string &queue, int flags, const AMQP::Table &arguments);
+DeferredConsumer &consume(const std::string &queue, int flags = 0);
+DeferredConsumer &consume(const std::string &queue, const AMQP::Table &arguments);
 ````
 
-As you can see, the consume method returns a DeferredConsumer. This object is a regular Deferred, with the
-addition of the onReceived method. This method can be used to retrieve incoming messages after consumption
-has begun.
+As you can see, the consume method returns a DeferredConsumer. This object is a 
+regular Deferred, with the some additions. The onSuccess() method of a 
+DeferredConsumer is slightly different than the onSuccess() method of a regular
+Deferred object: one extra parameter will be supplied to your callback function
+with the consumer tag.
 
+The onSuccess() callback will be called when the consume operation _has started_,
+but not when messages are actually consumed. For this you will have to install 
+a different callback, using the onReceived() method.
 
 ````c++
-channel.consume("my-queue").onReceived([](AMQP::Channel *channel, const AMQP::Message &message, uint64_t deliveryTag, const std::string &consumerTag, bool redelivered) {
-    // @todo
-    //  add your own processing
+// callback function that is called when the consume operation starts
+auto startCb = [](const std::string &consumertag) {
 
+    std::cout << "consume operation started" << std::endl;
+};
+
+// callback function that is called when the consume operation failed
+auto errorCb = [](const char *message) {
+
+    std::cout << "consume operation failed" << std::endl;
+}
+
+// callback operation when a message was received
+auto messageCb = [&channel](const AMQP::Message &message, uint64_t deliveryTag, bool redelivered) {
+
+    std::cout << "message received" << std::endl;
+    
+    // acknowledge the message
+    channel.ack(deliveryTag);
+}
+
+// start consuming from the queue, and install the callbacks
+channel.consume("my-queue")
+    .onSuccess(startCb)
+    .onError(errorCb)
+    .onReceived(messageCb);
 
-    // after the message was processed, acknowledge it
-    channel->ack(deliveryTag);
-});
 ````
 
-The Message object holds all information of the delivered message: the actual content,
-all meta information from the envelope (in fact, the Message class is derived from the Envelope class),
-and even the name of the exchange and the routing key that were used when the message was originally
-published. For a full list of all information in the Message class, you best have a look at the
+The Message object holds all information of the delivered message: the actual 
+content, all meta information from the envelope (in fact, the Message class is 
+derived from the Envelope class), and even the name of the exchange and the 
+routing key that were used when the message was originally published. For a full 
+list of all information in the Message class, you best have a look at the
 message.h, envelope.h and metadata.h header files.
 
-Another important parameter to the onReceived() method is the deliveryTag parameter. This is a
-unique identifier that you need to acknowledge an incoming message. RabbitMQ only removes the
-message after it has been acknowledged, so that if your application crashes while it was busy
-processing the message, the message does not get lost but remains in the queue. But this means that
-after you've processed the message, you must inform RabbitMQ about it by calling the Channel:ack()
-method. This method is very simple and takes in its simplest form only one parameter: the
+Another important parameter to the onReceived() method is the deliveryTag parameter. 
+This is a unique identifier that you need to acknowledge an incoming message. 
+RabbitMQ only removes the message after it has been acknowledged, so that if your 
+application crashes while it was busy processing the message, the message does 
+not get lost but remains in the queue. But this means that after you've processed 
+the message, you must inform RabbitMQ about it by calling the Channel:ack() method. 
+This method is very simple and takes in its simplest form only one parameter: the
 deliveryTag of the message.
 
-The consumerTag that you see in the onReceived method() is the same string identifier that was
-passed to the Channel::consume() method.
+Consuming messages is a continuous process. RabbitMQ keeps sending messages, until 
+you stop the consumer, which can be done by calling the Channel::cancel() method. 
+If you close the channel, or the entire TCP connection, consuming also stops.
 
-Consuming messages is a continuous process. RabbitMQ keeps sending messages, until you stop
-the consumer, which can be done by calling the Channel::cancel() method. If you close the channel,
-or the entire TCP connection, consuming also stops.
-
-RabbitMQ throttles the number of messages that are delivered to you, to prevent that your application
-is flooded with messages from the queue, and to spread out the messages over multiple consumers.
-This is done with a setting called quality-of-service (QOS). The QOS setting is a numeric value which
-holds the number of unacknowledged messages that you are allowed to have. RabbitMQ stops sending
-additional messages when the number of unacknowledges messages has reached this limit, and only
-sends additional messages when an earlier message gets acknowledged. To change the QOS, you can
-simple call Channel::setQos().
+RabbitMQ throttles the number of messages that are delivered to you, to prevent 
+that your application is flooded with messages from the queue, and to spread out 
+the messages over multiple consumers. This is done with a setting called 
+quality-of-service (QOS). The QOS setting is a numeric value which holds the number 
+of unacknowledged messages that you are allowed to have. RabbitMQ stops sending
+additional messages when the number of unacknowledges messages has reached this 
+limit, and only sends additional messages when an earlier message gets acknowledged. 
+To change the QOS, you can simple call Channel::setQos().
 
 
 WORK IN PROGRESS
diff --git a/include/connectionhandler.h b/include/connectionhandler.h
index 59c551e..17b98b2 100644
--- a/include/connectionhandler.h
+++ b/include/connectionhandler.h
@@ -48,7 +48,7 @@ public:
      *  @param  connection      The connection that entered the error state
      *  @param  message         Error message
      */
-    virtual void onError(Connection *connection, const std::string &message) {}
+    virtual void onError(Connection *connection, const char *message) {}
 
     /**
      *  Method that is called when the login attempt succeeded. After this method
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index bcbeed0..f3fceb2 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -273,7 +273,7 @@ public:
      *  Report an error message
      *  @param  message
      */
-    void reportError(const std::string &message)
+    void reportError(const char *message)
     {
         // set connection state to closed
         _state = state_closed;
diff --git a/src/connectioncloseframe.h b/src/connectioncloseframe.h
index 6bff24a..1c5059f 100644
--- a/src/connectioncloseframe.h
+++ b/src/connectioncloseframe.h
@@ -157,7 +157,7 @@ public:
         
         // no need to check for a channel, the error is connection wide
         // report the error on the connection
-        connection->reportError(text());
+        connection->reportError(text().c_str());
         
         // done
         return true;

From 44a9dff4136a424112e8baa55eb680145f19845e Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 14:27:16 +0200
Subject: [PATCH 31/41] removed channel handlers in readme

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 81de738..44c08d9 100644
--- a/README.md
+++ b/README.md
@@ -182,8 +182,8 @@ You should do all the book keeping for the buffer yourselves. If you for example
 call the Connection::parse() method with a buffer of 100 bytes, and the method 
 returns that only 60 bytes were processed, you should later call the method again, 
 with a buffer filled with the remaining 40 bytes. If the method returns 0, you should 
-make a new call to parse() when more data is available, with a buffer with more
-data.
+make a new call to parse() when more data is available, with a buffer that contains
+both the old data, and the new data.
 
 
 CHANNELS
@@ -269,7 +269,7 @@ for sending the first instruction to RabbitMQ.
 
 ````c++
 // create a channel
-Channel myChannel(connection, &myHandler);
+Channel myChannel(&connection);
 
 // install a generic channel-error handler that will be called for every
 // error that occurs on the channel
@@ -302,7 +302,7 @@ were already sent over it. This means that if you call multiple methods in a row
 and the first method fails, all subsequent methods will not be executed either:
 
 ````c++
-Channel myChannel(connection, &myHandler);
+Channel myChannel(&connection);
 myChannel.declareQueue("my-queue");
 myChannel.declareExchange("my-exchange");
 ````
@@ -316,8 +316,8 @@ state after the first failure.
 You can overcome this by using multiple channels:
 
 ````c++
-Channel channel1(connection, &myHandler);
-Channel channel2(connection, &myHandler);
+Channel channel1(&connection);
+Channel channel2(&connection);
 channel1.declareQueue("my-queue");
 channel2.declareExchange("my-exchange");
 ````

From b043c33cc6f170a0a9d4afaf4e5e048cb1236ce9 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 14:33:40 +0200
Subject: [PATCH 32/41] update documentation

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 44c08d9..ddc6605 100644
--- a/README.md
+++ b/README.md
@@ -287,8 +287,8 @@ myChannel.onReady([]() {
 });
 ````
 
-In theory, you should always use the onReady() function before you send any
-other instructions over the channel. In practive however, the AMQP library
+In theory, you should wait for the onReady() callback to be called before you 
+send any other instructions over the channel. In practice however, the AMQP library
 caches all instructions that were sent too early, so that you can use the
 channel object right after it was constructed.
 
@@ -562,7 +562,7 @@ DeferredConsumer &consume(const std::string &queue, const AMQP::Table &arguments
 ````
 
 As you can see, the consume method returns a DeferredConsumer. This object is a 
-regular Deferred, with the some additions. The onSuccess() method of a 
+regular Deferred, with  additions. The onSuccess() method of a 
 DeferredConsumer is slightly different than the onSuccess() method of a regular
 Deferred object: one extra parameter will be supplied to your callback function
 with the consumer tag.

From 59e0b61e6bf5c8a172a8e0906cd12ac573622c08 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Tue, 15 Apr 2014 14:49:03 +0200
Subject: [PATCH 33/41] installed test program, added onMessage() function in
 deferredconsumer

---
 include/channel.h          |  12 +-
 include/deferredconsumer.h |  17 ++-
 tests/Makefile             |  18 +++
 tests/README.md            |   2 +
 tests/a.out                | Bin 0 -> 1016087 bytes
 tests/main.cpp             |  54 +++++++++
 tests/myconnection.cpp     | 234 +++++++++++++++++++++++++++++++++++++
 tests/myconnection.h       | 118 +++++++++++++++++++
 tests/table/table.cpp      |  19 +++
 9 files changed, 467 insertions(+), 7 deletions(-)
 create mode 100644 tests/Makefile
 create mode 100644 tests/README.md
 create mode 100755 tests/a.out
 create mode 100644 tests/main.cpp
 create mode 100644 tests/myconnection.cpp
 create mode 100644 tests/myconnection.h
 create mode 100644 tests/table/table.cpp

diff --git a/include/channel.h b/include/channel.h
index 0f315c4..6f24a86 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -404,12 +404,12 @@ public:
      *
      *  });
      */
-    DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments) { return _implementation.consume(queue, tag, flags, arguments); }
-    DeferredConsumer& consume(const std::string &queue, const std::string &tag, int flags = 0) { return _implementation.consume(queue, tag, flags, Table()); }
-    DeferredConsumer& consume(const std::string &queue, const std::string &tag, const Table &arguments) { return _implementation.consume(queue, tag, 0, arguments); }
-    DeferredConsumer& consume(const std::string &queue, int flags, const Table &arguments) { return _implementation.consume(queue, std::string(), flags, arguments); }
-    DeferredConsumer& consume(const std::string &queue, int flags = 0) { return _implementation.consume(queue, std::string(), flags, Table()); }
-    DeferredConsumer& consume(const std::string &queue, const Table &arguments) { return _implementation.consume(queue, std::string(), 0, arguments); }
+    DeferredConsumer &consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments) { return _implementation.consume(queue, tag, flags, arguments); }
+    DeferredConsumer &consume(const std::string &queue, const std::string &tag, int flags = 0) { return _implementation.consume(queue, tag, flags, Table()); }
+    DeferredConsumer &consume(const std::string &queue, const std::string &tag, const Table &arguments) { return _implementation.consume(queue, tag, 0, arguments); }
+    DeferredConsumer &consume(const std::string &queue, int flags, const Table &arguments) { return _implementation.consume(queue, std::string(), flags, arguments); }
+    DeferredConsumer &consume(const std::string &queue, int flags = 0) { return _implementation.consume(queue, std::string(), flags, Table()); }
+    DeferredConsumer &consume(const std::string &queue, const Table &arguments) { return _implementation.consume(queue, std::string(), 0, arguments); }
 
     /**
      *  Cancel a running consume call
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
index 60104d1..ee82068 100644
--- a/include/deferredconsumer.h
+++ b/include/deferredconsumer.h
@@ -77,9 +77,24 @@ public:
 
     /**
      *  Register a function to be called when a message arrives
+     *  This fuction is also available as onMessage() because I always forget which name I gave to it
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer& onReceived(const MessageCallback &callback)
+    DeferredConsumer &onReceived(const MessageCallback &callback)
+    {
+        // store callback
+        _messageCallback = callback;
+        
+        // allow chaining
+        return *this;
+    }
+
+    /**
+     *  Register a function to be called when a message arrives
+     *  This fuction is also available as onMessage() because I always forget which name I gave to it
+     *  @param  callback    the callback to execute
+     */
+    DeferredConsumer &onMessage(const MessageCallback &callback)
     {
         // store callback
         _messageCallback = callback;
diff --git a/tests/Makefile b/tests/Makefile
new file mode 100644
index 0000000..b5bf2f3
--- /dev/null
+++ b/tests/Makefile
@@ -0,0 +1,18 @@
+CPP				= g++
+CPPFLAGS		= -Wall -c -I. -O2 -flto -std=c++11 -g
+LD				= g++
+LDFLAGS			= -lamqpcpp -lcopernica_event -lcopernica_network -lev
+RESULT			= a.out
+SOURCES			= $(wildcard *.cpp)
+OBJECTS			= $(SOURCES:%.cpp=%.o)
+
+all:	${OBJECTS} ${RESULT}
+
+${RESULT}: ${OBJECTS}
+	${LD} -o $@ ${OBJECTS} ${LDFLAGS}
+
+clean:
+	${RM} *.obj *~* ${OBJECTS} ${RESULT}
+
+${OBJECTS}:
+	${CPP} ${CPPFLAGS} -o $@ ${@:%.o=%.cpp}
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 0000000..07af04a
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,2 @@
+I'm sorry, the test case makes use of the closed source Copernica libraries. Maybe someone
+is willing to provide a test case based on plain system calls?
\ No newline at end of file
diff --git a/tests/a.out b/tests/a.out
new file mode 100755
index 0000000000000000000000000000000000000000..fe76148079ddc296418d5f7454c4959cdb7cc7c3
GIT binary patch
literal 1016087
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
Nzp%wWhbg&G`wz%Y$u0l@

literal 0
HcmV?d00001

diff --git a/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 0000000..fdd5ee0
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,54 @@
+/**
+ *  Main.cpp
+ *
+ *  Test program
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Global libraries that we need
+ */
+#include <amqpcpp.h>
+#include <copernica/network.h>
+
+/**
+ *  Namespaces to use
+ */
+using namespace std;
+using namespace Copernica;
+
+/**
+ *  Local libraries
+ */
+#include "myconnection.h"
+
+/**
+ *  Main procedure
+ *  @param  argc
+ *  @param  argv
+ *  @return int
+ */
+int main(int argc, const char *argv[])
+{   
+    // need an ip
+    if (argc != 2)
+    {
+        // report error
+        std::cerr << "usage: " << argv[0] << " <ip>" << std::endl;
+        
+        // done
+        return -1;
+    }
+    else
+    {
+        // create connection
+        MyConnection connection(argv[1]);
+
+        // start the main event loop
+        Event::MainLoop::instance()->run();
+
+        // done
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/tests/myconnection.cpp b/tests/myconnection.cpp
new file mode 100644
index 0000000..dd6e265
--- /dev/null
+++ b/tests/myconnection.cpp
@@ -0,0 +1,234 @@
+/**
+ *  MyConnection.cpp
+ *
+ *  @copyright 2014 Copernica BV
+ */
+ 
+/**
+ *  Required external libraries
+ */
+#include <amqpcpp.h>
+#include <copernica/network.h>
+ 
+#include <string>
+
+/**
+ *  Namespaces to use
+ */
+using namespace std;
+using namespace Copernica;
+ 
+/**
+ *  Required local class definitions
+ */
+#include "myconnection.h"
+
+/**
+ *  Constructor
+ */
+MyConnection::MyConnection(const std::string &ip) :
+    _socket(Event::MainLoop::instance(), this),
+    _connection(nullptr),
+    _channel(nullptr)
+{
+    // start connecting
+    if (_socket.connect(Network::Ipv4Address(ip), 5672)) return;
+    
+    // failure
+    onFailure(&_socket);
+}
+
+/**
+ *  Destructor
+ */
+MyConnection::~MyConnection()
+{
+    // do we still have a channel?
+    if (_channel)  delete _channel;
+    
+    // do we still have a connection?
+    if (_connection) delete _connection;
+}
+
+/**
+ *  Method that is called when the connection failed
+ *  @param  socket      Pointer to the socket
+ */
+void MyConnection::onFailure(Network::TcpSocket *socket)
+{
+    // report error
+    std::cout << "connect failure" << std::endl;
+}
+
+/**
+ *  Method that is called when the connection timed out (which also is a failure
+ *  @param  socket      Pointer to the socket
+ */
+void MyConnection::onTimeout(Network::TcpSocket *socket)
+{
+    // report error
+    std::cout << "connect timeout" << std::endl;
+}
+
+/**
+ *  Method that is called when the connection succeeded
+ *  @param  socket      Pointer to the socket
+ */
+void MyConnection::onConnected(Network::TcpSocket *socket)
+{
+    // report connection
+    std::cout << "connected" << std::endl;
+    
+    // we are connected, leap out if there already is a amqp connection
+    if (_connection) return;
+    
+    // create amqp connection, and a new channel
+    _connection = new AMQP::Connection(this, AMQP::Login("guest", "guest"), "/");
+    _channel = new AMQP::Channel(_connection);
+    
+    // install a handler when channel is in error
+    _channel->onError([](const char *message) {
+        
+        std::cout << "channel error " << message << std::endl;
+    });
+    
+    // install a handler when channel is ready
+    _channel->onReady([]() {
+        
+        std::cout << "channel ready" << std::endl;
+    });
+    
+    // we declare a queue, an exchange and we publish a message
+    _channel->declareQueue("my_queue").onSuccess([this]() { 
+        std::cout << "queue declared" << std::endl; 
+        
+        // start consuming
+        _channel->consume("my_queue").onReceived([](const AMQP::Message &message, uint64_t deliveryTag, bool redelivered) {
+            std::cout << "received: " << message.message() << std::endl;
+        });
+    });
+
+    // declare an exchange
+    _channel->declareExchange("my_exchange", AMQP::direct).onSuccess([]() { 
+        std::cout << "exchange declared" << std::endl; 
+    });
+    
+    // bind queue and exchange
+    _channel->bindQueue("my_exchange", "my_queue", "key").onSuccess([this]() {
+        std::cout << "queue bound to exchange" << std::endl;
+        
+        _channel->publish("my_exchange", "key", "just a message");
+    });
+}
+
+/**
+ *  Method that is called when the socket is closed (as a result of a TcpSocket::close() call)
+ *  @param  socket      Pointer to the socket
+ */
+void MyConnection::onClosed(Network::TcpSocket *socket)
+{
+    // show
+    std::cout << "myconnection closed" << std::endl;
+
+    // close the channel and connection
+    if (_channel) delete _channel;
+    if (_connection) delete _connection;
+    
+    // set to null
+    _channel = nullptr;
+    _connection = nullptr;
+}
+
+/**
+ *  Method that is called when the peer closed the connection
+ *  @param  socket      Pointer to the socket
+ */
+void MyConnection::onLost(Network::TcpSocket *socket)
+{
+    // report error
+    std::cout << "connection lost" << std::endl;
+    
+    // close the channel and connection
+    if (_channel) delete _channel;
+    if (_connection) delete _connection;
+    
+    // set to null
+    _channel = nullptr;
+    _connection = nullptr;
+}
+
+/**
+ *  Method that is called when data is received on the socket
+ *  @param  socket      Pointer to the socket
+ *  @param  buffer      Pointer to the fill input buffer
+ */
+void MyConnection::onData(Network::TcpSocket *socket, Network::Buffer *buffer)
+{
+    // send what came in
+    std::cout << "received: " << buffer->size() << " bytes" << std::endl;
+    
+    // leap out if there is no connection
+    if (!_connection) return;
+    
+    // let the data be handled by the connection
+    size_t bytes = _connection->parse(buffer->data(), buffer->size());
+    
+    // shrink the buffer
+    buffer->shrink(bytes);
+}
+
+/**
+ *  Method that is called when data needs to be sent over the network
+ *
+ *  Note that the AMQP library does no buffering by itself. This means 
+ *  that this method should always send out all data or do the buffering
+ *  itself.
+ *
+ *  @param  connection      The connection that created this output
+ *  @param  buffer          Data to send
+ *  @param  size            Size of the buffer
+ */
+void MyConnection::onData(AMQP::Connection *connection, const char *buffer, size_t size)
+{
+//    // report what is going on
+//    std::cout << "send: " << size << std::endl;
+//    
+//    for (unsigned i=0; i<size; i++) std::cout << (int)buffer[i] << " ";
+//    std::cout << std::endl;
+    
+    
+    // send to the socket
+    _socket.write(buffer, size);
+}
+
+/**
+ *  When the connection ends up in an error state this method is called.
+ *  This happens when data comes in that does not match the AMQP protocol
+ *  
+ *  After this method is called, the connection no longer is in a valid
+ *  state and can be used. In normal circumstances this method is not called.
+ *
+ *  @param  connection      The connection that entered the error state
+ *  @param  message         Error message
+ */
+void MyConnection::onError(AMQP::Connection *connection, const char *message)
+{
+    // report error
+    std::cout << "AMQP Connection error: " << message << std::endl;
+}
+
+/**
+ *  Method that is called when the login attempt succeeded. After this method
+ *  was called, the connection is ready to use
+ *
+ *  @param  connection      The connection that can now be used
+ */
+void MyConnection::onConnected(AMQP::Connection *connection)
+{
+    // show
+    std::cout << "AMQP login success" << std::endl;
+    
+    // create channel if it does not yet exist
+    if (!_channel) _channel = new AMQP::Channel(connection);
+}
+
diff --git a/tests/myconnection.h b/tests/myconnection.h
new file mode 100644
index 0000000..25fb710
--- /dev/null
+++ b/tests/myconnection.h
@@ -0,0 +1,118 @@
+/**
+ *  MyConnection.h
+ *
+ *  Our own test implementation for a connection handler
+ *
+ *  @copyright 2014 Copernica BV
+ */
+
+/**
+ *  Class definition
+ */
+class MyConnection : 
+    public AMQP::ConnectionHandler,
+    public Network::TcpHandler
+{
+private:
+    /**
+     *  The actual TCP socket that is connected with RabbitMQ
+     *  @var    TcpSocket
+     */
+    Network::TcpSocket _socket;
+    
+    /**
+     *  The AMQP connection
+     *  @var    Connection
+     */
+    AMQP::Connection *_connection;
+    
+    /**
+     *  The AMQP channel
+     *  @var    Channel
+     */
+    AMQP::Channel *_channel;
+
+    /**
+     *  Method that is called when the connection failed
+     *  @param  socket      Pointer to the socket
+     */
+    virtual void onFailure(Network::TcpSocket *socket) override;
+
+    /**
+     *  Method that is called when the connection timed out (which also is a failure
+     *  @param  socket      Pointer to the socket
+     */
+    virtual void onTimeout(Network::TcpSocket *socket) override;
+    
+    /**
+     *  Method that is called when the connection succeeded
+     *  @param  socket      Pointer to the socket
+     */
+    virtual void onConnected(Network::TcpSocket *socket) override;
+    
+    /**
+     *  Method that is called when the socket is closed (as a result of a TcpSocket::close() call)
+     *  @param  socket      Pointer to the socket
+     */
+    virtual void onClosed(Network::TcpSocket *socket) override;
+
+    /**
+     *  Method that is called when the peer closed the connection
+     *  @param  socket      Pointer to the socket
+     */
+    virtual void onLost(Network::TcpSocket *socket) override;
+    
+    /**
+     *  Method that is called when data is received on the socket
+     *  @param  socket      Pointer to the socket
+     *  @param  buffer      Pointer to the fill input buffer
+     */
+    virtual void onData(Network::TcpSocket *socket, Network::Buffer *buffer) override;
+    
+    /**
+     *  Method that is called when data needs to be sent over the network
+     *
+     *  Note that the AMQP library does no buffering by itself. This means 
+     *  that this method should always send out all data or do the buffering
+     *  itself.
+     *
+     *  @param  connection      The connection that created this output
+     *  @param  buffer          Data to send
+     *  @param  size            Size of the buffer
+     */
+    virtual void onData(AMQP::Connection *connection, const char *buffer, size_t size) override;
+    
+    /**
+     *  When the connection ends up in an error state this method is called.
+     *  This happens when data comes in that does not match the AMQP protocol
+     *  
+     *  After this method is called, the connection no longer is in a valid
+     *  state and can be used. In normal circumstances this method is not called.
+     *
+     *  @param  connection      The connection that entered the error state
+     *  @param  message         Error message
+     */
+    virtual void onError(AMQP::Connection *connection, const char *message) override;
+
+    /**
+     *  Method that is called when the login attempt succeeded. After this method
+     *  was called, the connection is ready to use
+     *
+     *  @param  connection      The connection that can now be used
+     */
+    virtual void onConnected(AMQP::Connection *connection) override;
+
+public:
+    /**
+     *  Constructor
+     *  @param  ip
+     */
+    MyConnection(const std::string &ip);
+    
+    /**
+     *  Destructor
+     */
+    virtual ~MyConnection();
+
+
+};
diff --git a/tests/table/table.cpp b/tests/table/table.cpp
new file mode 100644
index 0000000..8ff5e35
--- /dev/null
+++ b/tests/table/table.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+#include <amqpcpp.h>
+
+
+int main()
+{
+    AMQP::Array x;
+    
+    x[0] = "abc";
+    x[1] = "xyz";
+    
+    std::cout << x << std::endl;
+    std::cout << x[0] << std::endl;
+    std::cout << x[1] << std::endl;
+    
+
+    return 0;
+}
+

From 1fecc57d67bc5014b02b9c797592863658464237 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Wed, 16 Apr 2014 09:25:08 +0200
Subject: [PATCH 34/41] when a connection gets in error state, all deferred
 results will now also call their error callback, and the channel wide error
 handler is called _after_ all individual error handlers are called

---
 include/channelimpl.h    | 53 ++++++++++++++++++++++------------------
 include/connectionimpl.h | 13 ++++++++++
 src/channelimpl.cpp      | 26 --------------------
 3 files changed, 42 insertions(+), 50 deletions(-)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index 21ee2af..a4c4e39 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -479,12 +479,6 @@ public:
         if (!next) _newestCallback = nullptr;
     }
 
-    /**
-     *  Report errors to all deferred objects already in an error state
-     *  @param  force           Report errors even for objects not already in error state
-     */
-    void reportErrors(bool force = false);
-
     /**
      *  Report an error message on a channel
      *  @param  message
@@ -496,27 +490,38 @@ public:
 
         // we are going to call callbacks that could destruct the channel
         Monitor monitor(this);
+
+        // call the oldest
+        if (_oldestCallback)
+        {
+            // call the callback
+            auto *next = _oldestCallback->reportError(message);
+            
+            // leap out if channel no longer exists
+            if (!monitor.valid()) return;
+            
+            // set the oldest callback
+            _oldestCallback.reset(next);
+        }
+        
+        // clean up all deferred other objects
+        while (_oldestCallback)
+        {
+            // call the callback
+            auto *next = _oldestCallback->reportError("Channel is in error state");
+            
+            // leap out if channel no longer exists
+            if (!monitor.valid()) return;
+            
+            // set the oldest callback
+            _oldestCallback.reset(next);
+        }
+
+        // all callbacks have been processed, so we also can reset the pointer to the newest
+        _newestCallback = nullptr;
         
         // inform handler
         if (_errorCallback) _errorCallback(message);
-        
-        // leap out if channel is already destructed, or when there are no further callbacks
-        if (!monitor.valid() || !_oldestCallback) return;
-
-        // call the callback
-        auto *next = _oldestCallback->reportError(message);
-        
-        // leap out if channel no longer exists
-        if (!monitor.valid()) return;
-        
-        // set the oldest callback
-        _oldestCallback.reset(next);
-        
-        // if there was no next callback, the newest callback was just used
-        if (!next) _newestCallback = nullptr;
-        
-        // when one error occured, all subsequent messages are in an error state too
-        reportErrors(true);
     }
 
     /**
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index f3fceb2..bd654b2 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -277,6 +277,19 @@ public:
     {
         // set connection state to closed
         _state = state_closed;
+        
+        // monitor because every callback could invalidate the connection
+        Monitor monitor(this);
+
+        // all deferred result objects in the channels should report this error too
+        for (auto &iter : _channels)
+        {
+            // report the errors
+            iter.second->reportError(message);
+            
+            // leap out if no longer valid
+            if (!monitor.valid()) return;
+        }
 
         // inform handler
         _handler->onError(_parent, message);
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index f699692..c612232 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -119,32 +119,6 @@ Deferred &ChannelImpl::push(const Frame &frame)
     return push(new Deferred(send(frame)));
 }
 
-/**
- *  Report errors to all deferred objects already in an error state
- *  @param  force           Report errors even for objects not already in error state
- */
-void ChannelImpl::reportErrors(bool force)
-{
-    // keep looping for as long as the oldest callback is in an error state
-    while (_oldestCallback && (force || !*_oldestCallback))
-    {
-        // construct monitor, because channel could be destructed
-        Monitor monitor(this);
-        
-        // report the error
-        auto *next = _oldestCallback->reportError("Frame could not be delivered");
-        
-        // leap out if object is no longer valid after the callback was called
-        if (!monitor.valid()) return;
-        
-        // install the next deferred object
-        _oldestCallback.reset(next);
-        
-        // was this also the newest callback
-        if (!next) _newestCallback = nullptr;
-    }
-}
-
 /**
  *  Pause deliveries on a channel
  *

From e903cdb4ee33f0a61d52d4aa9c5dd79fc3a13b67 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Wed, 16 Apr 2014 11:43:27 +0200
Subject: [PATCH 35/41] the derived deferred classes now also re-implement the
 onSuccess() method to ensure that the same object type is returned, to
 support propert chaining

---
 include/channel.h          |  5 -----
 include/deferredcancel.h   | 12 ++++++++++--
 include/deferredconsumer.h | 18 +++++++++++++-----
 include/deferreddelete.h   | 12 ++++++++++--
 include/deferredqueue.h    | 12 ++++++++++--
 5 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/include/channel.h b/include/channel.h
index 6f24a86..618a314 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -334,11 +334,6 @@ public:
     /**
      *  Publish a message to an exchange
      *
-     *  If either of the two flags is set, and the message could not immediately
-     *  be published, the message is returned by the server to the client. If you
-     *  want to catch such returned messages, you need to install a handler using
-     *  the onReturned() method.
-     *
      *  @param  exchange    the exchange to publish to
      *  @param  routingkey  the routing key
      *  @param  envelope    the full envelope to send
diff --git a/include/deferredcancel.h b/include/deferredcancel.h
index 244e145..0c1f8e6 100644
--- a/include/deferredcancel.h
+++ b/include/deferredcancel.h
@@ -75,9 +75,17 @@ public:
     }
 
     /**
-     *  All the onSuccess() functions defined in the base class are accessible too
+     *  Register the function that is called when the cancel operation succeeded
+     *  @param  callback
      */
-    using Deferred::onSuccess;
+    DeferredCancel &onSuccess(const SuccessCallback &callback)
+    {
+        // call base
+        Deferred::onSuccess(callback);
+        
+        // allow chaining
+        return *this;
+    }
 };
 
 /**
diff --git a/include/deferredconsumer.h b/include/deferredconsumer.h
index ee82068..c656728 100644
--- a/include/deferredconsumer.h
+++ b/include/deferredconsumer.h
@@ -75,6 +75,19 @@ public:
         return *this;
     }
 
+    /**
+     *  Register the function that is called when the consumer starts
+     *  @param  callback
+     */
+    DeferredConsumer &onSuccess(const SuccessCallback &callback)
+    {
+        // call base
+        Deferred::onSuccess(callback);
+        
+        // allow chaining
+        return *this;
+    }
+
     /**
      *  Register a function to be called when a message arrives
      *  This fuction is also available as onMessage() because I always forget which name I gave to it
@@ -102,11 +115,6 @@ public:
         // allow chaining
         return *this;
     }
-
-    /**
-     *  All the onSuccess() functions defined in the base class are accessible too
-     */
-    using Deferred::onSuccess;
 };
 
 /**
diff --git a/include/deferreddelete.h b/include/deferreddelete.h
index 43ada61..aa0d83e 100644
--- a/include/deferreddelete.h
+++ b/include/deferreddelete.h
@@ -80,9 +80,17 @@ public:
     }
 
     /**
-     *  All the onSuccess() functions defined in the base class are accessible too
+     *  Register the function that is called when the queue is deleted or purged
+     *  @param  callback
      */
-    using Deferred::onSuccess;
+    DeferredDelete &onSuccess(const SuccessCallback &callback)
+    {
+        // call base
+        Deferred::onSuccess(callback);
+        
+        // allow chaining
+        return *this;
+    }
 };
 
 /**
diff --git a/include/deferredqueue.h b/include/deferredqueue.h
index 085f095..6b5d930 100644
--- a/include/deferredqueue.h
+++ b/include/deferredqueue.h
@@ -80,9 +80,17 @@ public:
     }
     
     /**
-     *  All the onSuccess() functions defined in the base class are accessible too
+     *  Register the function that is called when the queue is declared
+     *  @param  callback
      */
-    using Deferred::onSuccess;
+    DeferredQueue &onSuccess(const SuccessCallback &callback)
+    {
+        // call base
+        Deferred::onSuccess(callback);
+        
+        // allow chaining
+        return *this;
+    }
 };
 
 /**

From e0b709fa63ce47440d872f7b0e97142338a31b49 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Wed, 16 Apr 2014 12:04:44 +0200
Subject: [PATCH 36/41] in case of a connection error, we no longer call the
 channel wide error handler

---
 include/channelimpl.h    | 7 ++++---
 include/connectionimpl.h | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/channelimpl.h b/include/channelimpl.h
index a4c4e39..846c1b8 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -481,9 +481,10 @@ public:
 
     /**
      *  Report an error message on a channel
-     *  @param  message
+     *  @param  message             the error message
+     *  @param  notifyhandler       should the channel-wide handler also be called?
      */
-    void reportError(const char *message)
+    void reportError(const char *message, bool notifyhandler = true)
     {
         // change state
         _state = state_closed;
@@ -521,7 +522,7 @@ public:
         _newestCallback = nullptr;
         
         // inform handler
-        if (_errorCallback) _errorCallback(message);
+        if (notifyhandler && _errorCallback) _errorCallback(message);
     }
 
     /**
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index bd654b2..836d3a0 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -285,7 +285,7 @@ public:
         for (auto &iter : _channels)
         {
             // report the errors
-            iter.second->reportError(message);
+            iter.second->reportError(message, false);
             
             // leap out if no longer valid
             if (!monitor.valid()) return;

From a9570277b76830c060a5b51abf7cff63c2b1dbf2 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Tue, 29 Apr 2014 15:51:33 +0200
Subject: [PATCH 37/41] Removed the nowait option from the public interface,
 because the deferred would never be called and implemented a queue to wait
 for synchronous methods to complete before sending the next frame

---
 include/channel.h                |  53 ++-----------
 include/channelimpl.h            |  99 ++++++++++++++++--------
 include/connectionimpl.h         |   7 ++
 include/flags.h                  |   1 -
 include/outbuffer.h              |  20 ++---
 src/basicackframe.h              |  25 +++++--
 src/basiccancelframe.h           |  16 +++-
 src/basiccancelokframe.h         |   2 +-
 src/basicconsumeframe.h          |  12 +++
 src/basicconsumeokframe.h        |   2 +-
 src/basicdeliverframe.h          |  11 +++
 src/basicpublishframe.h          |  11 +++
 src/basicqosokframe.h            |   2 +-
 src/basicrecoverasyncframe.h     |  11 +++
 src/basicrecoverframe.h          |  11 +++
 src/basicrejectframe.h           |  11 +++
 src/basicreturnframe.h           |  11 +++
 src/channelcloseokframe.h        |  12 +--
 src/channelflowokframe.h         |   2 +-
 src/channelimpl.cpp              | 125 ++++++++++++++++++++-----------
 src/connectionimpl.cpp           |  50 ++++++++-----
 src/exchangebindframe.h          |  47 +++++++-----
 src/exchangebindokframe.h        |   2 +-
 src/exchangedeclareframe.h       |  12 +++
 src/exchangedeclareokframe.h     |   2 +-
 src/exchangedeleteframe.h        |  12 +++
 src/exchangedeleteokframe.h      |   2 +-
 src/exchangeunbindframe.h        |  49 +++++++-----
 src/exchangeunbindokframe.h      |   2 +-
 src/frame.h                      |  51 ++++++++++---
 src/methodframe.h                |   8 ++
 src/queuebindframe.h             |  12 +++
 src/queuebindokframe.h           |   2 +-
 src/queuedeclareframe.h          |  14 +++-
 src/queuedeclareokframe.h        |   2 +-
 src/queuedeleteframe.h           |  12 +++
 src/queuedeleteokframe.h         |   2 +-
 src/queuepurgeframe.h            |  26 +++++--
 src/queuepurgeokframe.h          |   2 +-
 src/queueunbindokframe.h         |   2 +-
 src/transactioncommitokframe.h   |   2 +-
 src/transactionrollbackokframe.h |   2 +-
 src/transactionselectokframe.h   |   2 +-
 43 files changed, 524 insertions(+), 237 deletions(-)

diff --git a/include/channel.h b/include/channel.h
index 618a314..e722ebb 100644
--- a/include/channel.h
+++ b/include/channel.h
@@ -174,42 +174,30 @@ public:
     /**
      *  Bind two exchanges to each other
      *
-     *  The following flags can be used for the exchange
-     *
-     *      -   nowait      do not wait on response
-     *
      *  @param  source      the source exchange
      *  @param  target      the target exchange
      *  @param  routingkey  the routing key
-     *  @param  flags       optional flags
      *  @param  arguments   additional bind arguments
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, flags, arguments); }
-    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, 0, arguments); }
-    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags = 0) { return _implementation.bindExchange(source, target, routingkey, flags, Table()); }
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments) { return _implementation.bindExchange(source, target, routingkey, arguments); }
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey) { return _implementation.bindExchange(source, target, routingkey, Table()); }
 
     /**
      *  Unbind two exchanges from one another
      *
-     *  The following flags can be used for the exchange
-     *
-     *      -   nowait      do not wait on response
-     *
      *  @param  target      the target exchange
      *  @param  source      the source exchange
      *  @param  routingkey  the routing key
-     *  @param  flags       optional flags
      *  @param  arguments   additional unbind arguments
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, flags, arguments); }
-    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, 0, arguments); }
-    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, int flags = 0) { return _implementation.unbindExchange(target, source, routingkey, flags, Table()); }
+    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey, const Table &arguments) { return _implementation.unbindExchange(target, source, routingkey, arguments); }
+    Deferred &unbindExchange(const std::string &target, const std::string &source, const std::string &routingkey) { return _implementation.unbindExchange(target, source, routingkey, Table()); }
 
     /**
      *  Declare a queue
@@ -250,22 +238,16 @@ public:
     /**
      *  Bind a queue to an exchange
      *
-     *  The following flags can be used for the exchange
-     *
-     *      -   nowait      do not wait on response
-     *
      *  @param  exchange    the source exchange
      *  @param  queue       the target queue
      *  @param  routingkey  the routing key
-     *  @param  flags       additional flags
      *  @param  arguments   additional bind arguments
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, flags, arguments); }
-    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, 0, arguments); }
-    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, int flags = 0) { return _implementation.bindQueue(exchange, queue, routingkey, flags, Table()); }
+    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey, const Table &arguments) { return _implementation.bindQueue(exchange, queue, routingkey, arguments); }
+    Deferred &bindQueue(const std::string &exchange, const std::string &queue, const std::string &routingkey) { return _implementation.bindQueue(exchange, queue, routingkey, Table()); }
 
     /**
      *  Unbind a queue from an exchange
@@ -283,12 +265,7 @@ public:
     /**
      *  Purge a queue
      *
-     *  The following flags can be used for the exchange
-     *
-     *      -   nowait      do not wait on response
-     *
      *  @param  name        name of the queue
-     *  @param  flags       additional flags
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
@@ -303,7 +280,7 @@ public:
      *
      *  });
      */
-    DeferredDelete &purgeQueue(const std::string &name, int flags = 0){ return _implementation.purgeQueue(name, flags); }
+    DeferredDelete &purgeQueue(const std::string &name){ return _implementation.purgeQueue(name); }
 
     /**
      *  Remove a queue
@@ -375,11 +352,6 @@ public:
      *      -   nolocal             if set, messages published on this channel are not also consumed
      *      -   noack               if set, consumed messages do not have to be acked, this happens automatically
      *      -   exclusive           request exclusive access, only this consumer can access the queue
-     *      -   nowait              the server does not have to send a response back that consuming is active
-     *
-     *  The method Deferred::onSuccess() will be called when the
-     *  consumer has started (unless the nowait option was set, in which case
-     *  no confirmation method is called)
      *
      *  @param  queue               the queue from which you want to consume
      *  @param  tag                 a consumer tag that will be associated with this consume operation
@@ -411,16 +383,7 @@ public:
      *
      *  If you want to stop a running consumer, you can use this method with the consumer tag
      *
-     *  The following flags are supported:
-     *
-     *      -   nowait              the server does not have to send a response back that the consumer has been cancelled
-     *
-     *  The method Deferred::onSuccess() will be called when the consumer
-     *  was succesfully stopped (unless the nowait option was used, in which case no
-     *  confirmation method is called)
-     *
      *  @param  tag                 the consumer tag
-     *  @param  flags               optional additional flags
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
@@ -435,7 +398,7 @@ public:
      *
      *  });
      */
-    DeferredCancel &cancel(const std::string &tag, int flags = 0) { return _implementation.cancel(tag, flags); }
+    DeferredCancel &cancel(const std::string &tag) { return _implementation.cancel(tag); }
 
     /**
      *  Acknoldge a received message
diff --git a/include/channelimpl.h b/include/channelimpl.h
index 846c1b8..062c160 100644
--- a/include/channelimpl.h
+++ b/include/channelimpl.h
@@ -58,18 +58,18 @@ private:
     /**
      *  Pointer to the oldest deferred result (the first one that is going
      *  to be executed)
-     * 
+     *
      *  @var    Deferred
      */
     std::unique_ptr<Deferred> _oldestCallback = nullptr;
-    
+
     /**
      *  Pointer to the newest deferred result (the last one to be added).
-     * 
+     *
      *  @var    Deferred
      */
     Deferred *_newestCallback = nullptr;
-    
+
     /**
      *  The channel number
      *  @var uint16_t
@@ -86,6 +86,19 @@ private:
         state_closed
     } _state = state_connected;
 
+    /**
+     *  The frames that still need to be send out
+     *
+     *  We store the data as well as whether they
+     *  should be handled synchronously.
+     */
+    std::queue<std::pair<bool, OutBuffer>> _queue;
+
+    /**
+     *  Are we currently operating in synchronous mode?
+     */
+    bool _synchronous = false;
+
     /**
      *  The message that is now being received
      *  @var ConsumedMessage
@@ -203,13 +216,12 @@ public:
      *  @param  source      exchange which binds to target
      *  @param  target      exchange to bind to
      *  @param  routingKey  routing key
-     *  @param  glags       additional flags
      *  @param  arguments   additional arguments for binding
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments);
 
     /**
      *  unbind two exchanges
@@ -217,13 +229,12 @@ public:
      *  @param  source      the source exchange
      *  @param  target      the target exchange
      *  @param  routingkey  the routing key
-     *  @param  flags       optional flags
      *  @param  arguments   additional unbind arguments
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments);
 
     /**
      *  remove an exchange
@@ -253,13 +264,12 @@ public:
      *  @param  exchangeName    name of the exchange to bind to
      *  @param  queueName       name of the queue
      *  @param  routingkey      routingkey
-     *  @param  flags           additional flags
      *  @param  arguments       additional arguments
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
      */
-    Deferred &bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments);
+    Deferred &bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments);
 
     /**
      *  Unbind a queue from an exchange
@@ -277,7 +287,6 @@ public:
     /**
      *  Purge a queue
      *  @param  queue       queue to purge
-     *  @param  flags       additional flags
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
@@ -292,7 +301,7 @@ public:
      *
      *  });
      */
-    DeferredDelete &purgeQueue(const std::string &name, int flags);
+    DeferredDelete &purgeQueue(const std::string &name);
 
     /**
      *  Remove a queue
@@ -363,7 +372,6 @@ public:
     /**
      *  Cancel a running consumer
      *  @param  tag                 the consumer tag
-     *  @param  flags               optional flags
      *
      *  This function returns a deferred handler. Callbacks can be installed
      *  using onSuccess(), onError() and onFinalize() methods.
@@ -378,7 +386,7 @@ public:
      *
      *  });
      */
-    DeferredCancel &cancel(const std::string &tag, int flags);
+    DeferredCancel &cancel(const std::string &tag);
 
     /**
      *  Acknowledge a message
@@ -429,54 +437,79 @@ public:
      */
     bool send(const Frame &frame);
 
+    /**
+     *  Signal the channel that a synchronous operation
+     *  was completed. After this operation, waiting
+     *  frames can be sent out.
+     */
+    void synchronized();
+
     /**
      *  Report to the handler that the channel is opened
      */
     void reportReady()
     {
+        // callbacks could destroy us, so monitor it
+        Monitor monitor(this);
+
         // inform handler
         if (_readyCallback) _readyCallback();
+
+        // if the monitor is still valid, we exit synchronous mode now
+        if (monitor.valid()) synchronized();
     }
 
     /**
      *  Report to the handler that the channel is closed
+     *
+     *  Returns whether the channel object is still valid
      */
-    void reportClosed()
+    bool reportClosed()
     {
         // change state
         _state = state_closed;
 
         // and pass on to the reportSuccess() method which will call the
         // appropriate deferred object to report the successful operation
-        reportSuccess();
+        return reportSuccess();
+
+        // technically, we should exit synchronous method now
+        // since the synchronous channel close frame has been
+        // acknowledged by the server.
+        //
+        // but since the channel was just closed, there is no
+        // real point in doing this, as we cannot send frames
+        // out anymore.
     }
 
     /**
      *  Report success
      *
-     *  This function is called to report success for all
-     *  cases where the callback does not receive any parameters
+     *  Returns whether the channel object is still valid
      */
     template <typename... Arguments>
-    void reportSuccess(Arguments ...parameters)
+    bool reportSuccess(Arguments ...parameters)
     {
         // skip if there is no oldest callback
-        if (!_oldestCallback) return;
-     
+        if (!_oldestCallback) return true;
+
         // we are going to call callbacks that could destruct the channel
         Monitor monitor(this);
-     
+
         // call the callback
         auto *next = _oldestCallback->reportSuccess(std::forward<Arguments>(parameters)...);
-        
+
         // leap out if channel no longer exists
-        if (!monitor.valid()) return;
-        
+        if (!monitor.valid()) return false;
+
         // set the oldest callback
         _oldestCallback.reset(next);
-        
+
         // if there was no next callback, the newest callback was just used
         if (!next) _newestCallback = nullptr;
+
+        // we are still valid
+        return true;
     }
 
     /**
@@ -497,30 +530,30 @@ public:
         {
             // call the callback
             auto *next = _oldestCallback->reportError(message);
-            
+
             // leap out if channel no longer exists
             if (!monitor.valid()) return;
-            
+
             // set the oldest callback
             _oldestCallback.reset(next);
         }
-        
+
         // clean up all deferred other objects
         while (_oldestCallback)
         {
             // call the callback
             auto *next = _oldestCallback->reportError("Channel is in error state");
-            
+
             // leap out if channel no longer exists
             if (!monitor.valid()) return;
-            
+
             // set the oldest callback
             _oldestCallback.reset(next);
         }
 
         // all callbacks have been processed, so we also can reset the pointer to the newest
         _newestCallback = nullptr;
-        
+
         // inform handler
         if (notifyhandler && _errorCallback) _errorCallback(message);
     }
@@ -534,7 +567,7 @@ public:
     {
         // install the callback if it is assigned
         if (callback) _consumers[consumertag] = callback;
-        
+
         // otherwise we erase the previously set callback
         else _consumers.erase(consumertag);
     }
diff --git a/include/connectionimpl.h b/include/connectionimpl.h
index 836d3a0..530888a 100644
--- a/include/connectionimpl.h
+++ b/include/connectionimpl.h
@@ -253,6 +253,13 @@ public:
      */
     bool send(const Frame &frame);
 
+    /**
+     *  Send buffered data over the connection
+     *
+     *  @param  buffer      the buffer with data to send
+     */
+    bool send(OutBuffer &&buffer);
+
     /**
      *  Get a channel by its identifier
      *
diff --git a/include/flags.h b/include/flags.h
index 5f46b52..c2de72f 100644
--- a/include/flags.h
+++ b/include/flags.h
@@ -26,7 +26,6 @@ extern const int global;
 extern const int nolocal;
 extern const int noack;
 extern const int exclusive;
-extern const int nowait;
 extern const int mandatory;
 extern const int immediate;
 extern const int redelivered;
diff --git a/include/outbuffer.h b/include/outbuffer.h
index 24833fa..54d5988 100644
--- a/include/outbuffer.h
+++ b/include/outbuffer.h
@@ -24,7 +24,7 @@ private:
      *  @var char*
      */
     char *_buffer;
-    
+
     /**
      *  Pointer to the buffer to be filled
      *  @var char*
@@ -36,13 +36,13 @@ private:
      *  @var size_t
      */
     size_t _size;
-    
+
     /**
      *  The total capacity of the out buffer
      *  @var size_t
      */
     size_t _capacity;
-    
+
 
 public:
     /**
@@ -56,7 +56,7 @@ public:
         _capacity = capacity;
         _buffer = _current = new char[capacity];
     }
-    
+
     /**
      *  Copy constructor
      *  @param  that
@@ -68,11 +68,11 @@ public:
         _capacity = that._capacity;
         _buffer = new char[_capacity];
         _current = _buffer + _size;
-        
+
         // copy memory
         memcpy(_buffer, that._buffer, _size);
     }
-    
+
     /**
      *  Move constructor
      *  @param  that
@@ -84,7 +84,7 @@ public:
         _capacity = that._capacity;
         _buffer = that._buffer;
         _current = that._current;
-        
+
         // reset the other object
         that._size = 0;
         that._capacity = 0;
@@ -95,7 +95,7 @@ public:
     /**
      *  Destructor
      */
-    virtual ~OutBuffer() 
+    virtual ~OutBuffer()
     {
         if (_buffer) delete[] _buffer;
     }
@@ -104,7 +104,7 @@ public:
      *  Get access to the internal buffer
      *  @return const char*
      */
-    const char *data()
+    const char *data() const
     {
         return _buffer;
     }
@@ -113,7 +113,7 @@ public:
      *  Current size of the output buffer
      *  @return size_t
      */
-    size_t size()
+    size_t size() const
     {
         return _size;
     }
diff --git a/src/basicackframe.h b/src/basicackframe.h
index 8337b9f..7549155 100644
--- a/src/basicackframe.h
+++ b/src/basicackframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a basic acknowledgement frame
- *  
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -38,10 +38,10 @@ protected:
     {
         // call base
         BasicFrame::fill(buffer);
-        
+
         // add the delivery tag
         buffer.add(_deliveryTag);
-        
+
         // add the booleans
         _multiple.fill(buffer);
     }
@@ -54,25 +54,36 @@ public:
      *  @param  deliveryTag     server-assigned and channel specific delivery tag
      *  @param  multiple        acknowledge mutiple messages
      */
-    BasicAckFrame(uint16_t channel, uint64_t deliveryTag, bool multiple = false) : 
+    BasicAckFrame(uint16_t channel, uint64_t deliveryTag, bool multiple = false) :
         BasicFrame(channel, 9),
         _deliveryTag(deliveryTag),
         _multiple(multiple) {}
-    
+
     /**
      *  Construct based on received frame
      *  @param  frame
      */
-    BasicAckFrame(ReceivedFrame &frame) : 
+    BasicAckFrame(ReceivedFrame &frame) :
         BasicFrame(frame),
         _deliveryTag(frame.nextUint64()),
         _multiple(frame) {}
-    
+
     /**
      *  Destructor
      */
     virtual ~BasicAckFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    virtual bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the method ID
      *  @return  uint16_t
diff --git a/src/basiccancelframe.h b/src/basiccancelframe.h
index ea65d3e..e665ab2 100644
--- a/src/basiccancelframe.h
+++ b/src/basiccancelframe.h
@@ -67,7 +67,19 @@ public:
      *  Destructor
      */
     virtual ~BasicCancelFrame() {}
-    
+
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous when the nowait option is not used
+        return !noWait();
+    }
+
     /**
      *  Return the consumertag, which is specified by the client or provided by the server
      *  @return  string
@@ -90,7 +102,7 @@ public:
      *  Return whether to wait for a response
      *  @return  boolean
      */
-    const bool noWait()
+    const bool noWait() const
     {
         return _noWait.get(0);
     }
diff --git a/src/basiccancelokframe.h b/src/basiccancelokframe.h
index 6d9d42f..6592166 100644
--- a/src/basiccancelokframe.h
+++ b/src/basiccancelokframe.h
@@ -94,7 +94,7 @@ public:
         if (!channel) return false;
 
         // report
-        channel->reportSuccess<const std::string&>(consumerTag());
+        if (channel->reportSuccess<const std::string&>(consumerTag())) channel->synchronized();
 
         // done
         return true;
diff --git a/src/basicconsumeframe.h b/src/basicconsumeframe.h
index 0bc7888..7e57eee 100644
--- a/src/basicconsumeframe.h
+++ b/src/basicconsumeframe.h
@@ -111,6 +111,18 @@ public:
      */
     virtual ~BasicConsumeFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous when the nowait option is not set
+        return !noWait();
+    }
+
     /**
      *  Return the method ID
      *  @return uint16_t
diff --git a/src/basicconsumeokframe.h b/src/basicconsumeokframe.h
index 31c44ef..e767f0f 100644
--- a/src/basicconsumeokframe.h
+++ b/src/basicconsumeokframe.h
@@ -94,7 +94,7 @@ public:
         if (!channel) return false;
 
         // report
-        channel->reportSuccess(consumerTag());
+        if (channel->reportSuccess(consumerTag())) channel->synchronized();
 
         // done
         return true;
diff --git a/src/basicdeliverframe.h b/src/basicdeliverframe.h
index aef677f..ac6128d 100644
--- a/src/basicdeliverframe.h
+++ b/src/basicdeliverframe.h
@@ -120,6 +120,17 @@ public:
         return _routingKey;
     }
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    virtual bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the method ID
      *  @return  uint16_t
diff --git a/src/basicpublishframe.h b/src/basicpublishframe.h
index 9f9eb69..975c2ab 100644
--- a/src/basicpublishframe.h
+++ b/src/basicpublishframe.h
@@ -94,6 +94,17 @@ public:
      */
     virtual ~BasicPublishFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the name of the exchange to publish to
      *  @return  string
diff --git a/src/basicqosokframe.h b/src/basicqosokframe.h
index dc6e612..9c235e2 100644
--- a/src/basicqosokframe.h
+++ b/src/basicqosokframe.h
@@ -67,7 +67,7 @@ public:
         if (!channel) return false;
 
         // report
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/basicrecoverasyncframe.h b/src/basicrecoverasyncframe.h
index 7d7e036..68eb3ec 100644
--- a/src/basicrecoverasyncframe.h
+++ b/src/basicrecoverasyncframe.h
@@ -62,6 +62,17 @@ public:
      */
     virtual ~BasicRecoverAsyncFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    virtual bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the method ID
      *  @return  uint16_t
diff --git a/src/basicrecoverframe.h b/src/basicrecoverframe.h
index d378393..ca67f16 100644
--- a/src/basicrecoverframe.h
+++ b/src/basicrecoverframe.h
@@ -62,6 +62,17 @@ public:
      */
     virtual ~BasicRecoverFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the method ID
      *  @return  uint16_t
diff --git a/src/basicrejectframe.h b/src/basicrejectframe.h
index c5c1f6b..a77d7da 100644
--- a/src/basicrejectframe.h
+++ b/src/basicrejectframe.h
@@ -73,6 +73,17 @@ public:
      */ 
     virtual ~BasicRejectFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      * Return the method ID
      * @return  uint16_t
diff --git a/src/basicreturnframe.h b/src/basicreturnframe.h
index 6bb8aef..2fedce6 100644
--- a/src/basicreturnframe.h
+++ b/src/basicreturnframe.h
@@ -92,6 +92,17 @@ public:
      */
     virtual ~BasicReturnFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    virtual bool synchronous() const override
+    {
+        return false;
+    }
+
     /**
      *  Return the name of the exchange to publish to
      *  @return  string
diff --git a/src/channelcloseokframe.h b/src/channelcloseokframe.h
index 5eb5cda..d06e845 100644
--- a/src/channelcloseokframe.h
+++ b/src/channelcloseokframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing a channel close acknowledgement frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -67,13 +67,13 @@ public:
     {
         // we need the appropriate channel
         ChannelImpl *channel = connection->channel(this->channel());
-        
+
         // channel does not exist
-        if (!channel) return false;    
-        
+        if (!channel) return false;
+
         // report that the channel is closed
-        channel->reportClosed();
-        
+        if (channel->reportClosed()) channel->synchronized();
+
         // done
         return true;
     }
diff --git a/src/channelflowokframe.h b/src/channelflowokframe.h
index fcd325f..c335564 100644
--- a/src/channelflowokframe.h
+++ b/src/channelflowokframe.h
@@ -93,7 +93,7 @@ public:
         if (!channel) return false;
 
         // report success for the call
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index c612232..0b917f4 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -85,7 +85,7 @@ ChannelImpl::~ChannelImpl()
 
     // close the channel now
     close();
-    
+
     // destruct deferred results
     while (_oldestCallback) _oldestCallback.reset(_oldestCallback->next());
 }
@@ -98,13 +98,13 @@ Deferred &ChannelImpl::push(Deferred *deferred)
 {
     // do we already have an oldest?
     if (!_oldestCallback) _oldestCallback.reset(deferred);
-    
+
     // do we already have a newest?
     if (_newestCallback) _newestCallback->add(deferred);
-    
+
     // store newest callback
     _newestCallback = deferred;
-    
+
     // done
     return *deferred;
 }
@@ -222,7 +222,7 @@ Deferred &ChannelImpl::declareExchange(const std::string &name, ExchangeType typ
     if (type == ExchangeType::headers)exchangeType = "headers";
 
     // send declare exchange frame
-    return push(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, flags & nowait, arguments));
+    return push(ExchangeDeclareFrame(_id, name, exchangeType, flags & passive, flags & durable, false, arguments));
 }
 
 /**
@@ -231,16 +231,15 @@ Deferred &ChannelImpl::declareExchange(const std::string &name, ExchangeType typ
  *  @param  source      exchange which binds to target
  *  @param  target      exchange to bind to
  *  @param  routingKey  routing key
- *  @param  flags       additional flags
  *  @param  arguments   additional arguments for binding
  *
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments)
 {
     // send exchange bind frame
-    return push(ExchangeBindFrame(_id, target, source, routingkey, flags & nowait, arguments));
+    return push(ExchangeBindFrame(_id, target, source, routingkey, false, arguments));
 }
 
 /**
@@ -249,16 +248,15 @@ Deferred &ChannelImpl::bindExchange(const std::string &source, const std::string
  *  @param  source      the source exchange
  *  @param  target      the target exchange
  *  @param  routingkey  the routing key
- *  @param  flags       optional flags
  *  @param  arguments   additional unbind arguments
  *
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::string &target, const std::string &routingkey, const Table &arguments)
 {
     // send exchange unbind frame
-    return push(ExchangeUnbindFrame(_id, target, source, routingkey, flags & nowait, arguments));
+    return push(ExchangeUnbindFrame(_id, target, source, routingkey, false, arguments));
 }
 
 /**
@@ -273,7 +271,7 @@ Deferred &ChannelImpl::unbindExchange(const std::string &source, const std::stri
 Deferred &ChannelImpl::removeExchange(const std::string &name, int flags)
 {
     // send delete exchange frame
-    return push(ExchangeDeleteFrame(_id, name, flags & ifunused, flags & nowait));
+    return push(ExchangeDeleteFrame(_id, name, flags & ifunused, false));
 }
 
 /**
@@ -288,14 +286,14 @@ Deferred &ChannelImpl::removeExchange(const std::string &name, int flags)
 DeferredQueue &ChannelImpl::declareQueue(const std::string &name, int flags, const Table &arguments)
 {
     // the frame to send
-    QueueDeclareFrame frame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, flags & nowait, arguments);
-    
+    QueueDeclareFrame frame(_id, name, flags & passive, flags & durable, flags & exclusive, flags & autodelete, false, arguments);
+
     // send the queuedeclareframe
     auto *result = new DeferredQueue(send(frame));
-    
+
     // add the deferred result
     push(result);
-    
+
     // done
     return *result;
 }
@@ -306,16 +304,15 @@ DeferredQueue &ChannelImpl::declareQueue(const std::string &name, int flags, con
  *  @param  exchangeName    name of the exchange to bind to
  *  @param  queueName       name of the queue
  *  @param  routingkey      routingkey
- *  @param  flags           additional flags
  *  @param  arguments       additional arguments
  *
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
  */
-Deferred &ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, int flags, const Table &arguments)
+Deferred &ChannelImpl::bindQueue(const std::string &exchangeName, const std::string &queueName, const std::string &routingkey, const Table &arguments)
 {
     // send the bind queue frame
-    return push(QueueBindFrame(_id, queueName, exchangeName, routingkey, flags & nowait, arguments));
+    return push(QueueBindFrame(_id, queueName, exchangeName, routingkey, false, arguments));
 }
 
 /**
@@ -338,7 +335,6 @@ Deferred &ChannelImpl::unbindQueue(const std::string &exchange, const std::strin
 /**
  *  Purge a queue
  *  @param  queue       queue to purge
- *  @param  flags       additional flags
  *
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
@@ -353,17 +349,17 @@ Deferred &ChannelImpl::unbindQueue(const std::string &exchange, const std::strin
  *
  *  });
  */
-DeferredDelete &ChannelImpl::purgeQueue(const std::string &name, int flags)
+DeferredDelete &ChannelImpl::purgeQueue(const std::string &name)
 {
-    // the frame to send 
-    QueuePurgeFrame frame(_id, name, flags & nowait);
-    
+    // the frame to send
+    QueuePurgeFrame frame(_id, name, false);
+
     // send the frame, and create deferred object
     auto *deferred = new DeferredDelete(send(frame));
-    
+
     // push to list
     push(deferred);
-    
+
     // done
     return *deferred;
 }
@@ -389,14 +385,14 @@ DeferredDelete &ChannelImpl::purgeQueue(const std::string &name, int flags)
 DeferredDelete &ChannelImpl::removeQueue(const std::string &name, int flags)
 {
     // the frame to send
-    QueueDeleteFrame frame(_id, name, flags & ifunused, flags & ifempty, flags & nowait);
+    QueueDeleteFrame frame(_id, name, flags & ifunused, flags & ifempty, false);
 
     // send the frame, and create deferred object
     auto *deferred = new DeferredDelete(send(frame));
-    
+
     // push to list
     push(deferred);
-    
+
     // done
     return *deferred;
 }
@@ -495,14 +491,14 @@ Deferred &ChannelImpl::setQos(uint16_t prefetchCount)
 DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::string &tag, int flags, const Table &arguments)
 {
     // the frame to send
-    BasicConsumeFrame frame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, flags & nowait, arguments);
-    
+    BasicConsumeFrame frame(_id, queue, tag, flags & nolocal, flags & noack, flags & exclusive, false, arguments);
+
     // send the frame, and create deferred object
     auto *deferred = new DeferredConsumer(this, send(frame));
-    
+
     // push to list
     push(deferred);
-    
+
     // done
     return *deferred;
 }
@@ -510,7 +506,6 @@ DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::stri
 /**
  *  Cancel a running consumer
  *  @param  tag                 the consumer tag
- *  @param  flags               optional flags
  *
  *  This function returns a deferred handler. Callbacks can be installed
  *  using onSuccess(), onError() and onFinalize() methods.
@@ -525,17 +520,17 @@ DeferredConsumer& ChannelImpl::consume(const std::string &queue, const std::stri
  *
  *  });
  */
-DeferredCancel &ChannelImpl::cancel(const std::string &tag, int flags)
+DeferredCancel &ChannelImpl::cancel(const std::string &tag)
 {
     // the cancel frame to send
-    BasicCancelFrame frame(_id, tag, flags & nowait);
+    BasicCancelFrame frame(_id, tag, false);
 
     // send the frame, and create deferred object
     auto *deferred = new DeferredCancel(this, send(frame));
-    
+
     // push to list
     push(deferred);
-    
+
     // done
     return *deferred;
 }
@@ -587,10 +582,56 @@ bool ChannelImpl::send(const Frame &frame)
     // skip if channel is not connected
     if (_state != state_connected || !_connection) return false;
 
+    // are we currently in synchronous mode or are there
+    // other frames waiting for their turn to be sent?
+    if (_synchronous || !_queue.empty())
+    {
+        // we need to wait until the synchronous frame has
+        // been processed, so queue the frame until it was
+        _queue.emplace(frame.synchronous(), frame.buffer());
+
+        // it was of course not actually sent but we pretend
+        // that it was, because no error occured
+        return true;
+    }
+
+    // enter synchronous mode if necessary
+    _synchronous = frame.synchronous();
+
     // send to tcp connection
     return _connection->send(frame);
 }
 
+/**
+ *  Signal the channel that a synchronous operation
+ *  was completed. After this operation, waiting
+ *  frames can be sent out.
+ */
+void ChannelImpl::synchronized()
+{
+    // we are no longer waiting for synchronous operations
+    _synchronous = false;
+
+    // we need to monitor the channel for validity
+    Monitor monitor(this);
+
+    // send all frames while not in synchronous mode
+    while (monitor.valid() && !_synchronous && !_queue.empty())
+    {
+        // retrieve the first buffer and synchronous
+        auto pair = std::move(_queue.front());
+
+        // remove from the list
+        _queue.pop();
+
+        // mark as synchronous if necessary
+        _synchronous = pair.first;
+
+        // send it over the connection
+        _connection->send(std::move(pair.second));
+    }
+}
+
 /**
  *  Report the received message
  */
@@ -602,16 +643,16 @@ void ChannelImpl::reportMessage()
     // look for the consumer
     auto iter = _consumers.find(_message->consumer());
     if (iter == _consumers.end()) return;
-    
+
     // is this a valid callback method
     if (!iter->second) return;
 
     // after the report the channel may be destructed, monitor that
     Monitor monitor(this);
-    
+
     // call the callback
     _message->report(iter->second);
-    
+
     // skip if channel was destructed
     if (!monitor.valid()) return;
 
@@ -628,7 +669,7 @@ ConsumedMessage *ChannelImpl::message(const BasicDeliverFrame &frame)
 {
     // destruct if message is already set
     if (_message) delete _message;
-    
+
     // construct a message
     return _message = new ConsumedMessage(frame);
 }
diff --git a/src/connectionimpl.cpp b/src/connectionimpl.cpp
index 668fbb3..a26f903 100644
--- a/src/connectionimpl.cpp
+++ b/src/connectionimpl.cpp
@@ -213,9 +213,9 @@ void ConnectionImpl::setConnected()
     // store connected state
     _state = state_connected;
 
-    // if the close operation was already called, we do that again now again
-    // so that the actual messages to close down the connection and the channel
-    // are appended to the queue
+    // if the close method was called before, the frame was not
+    // sent. append it to the end of the queue to make sure we
+    // are correctly closed down.
     if (_closed && !sendClose()) return;
 
     // we're going to call the handler, which can destruct the connection,
@@ -225,11 +225,8 @@ void ConnectionImpl::setConnected()
     // inform handler
     _handler->onConnected(_parent);
 
-    // leap out if the connection no longer exists
-    if (!monitor.valid()) return;
-
     // empty the queue of messages
-    while (!_queue.empty())
+    while (monitor.valid() && !_queue.empty())
     {
         // get the next message
         OutBuffer buffer(std::move(_queue.front()));
@@ -239,9 +236,6 @@ void ConnectionImpl::setConnected()
 
         // send it
         _handler->onData(_parent, buffer.data(), buffer.size());
-
-        // leap out if the connection was destructed
-        if (!monitor.valid()) return;
     }
 }
 
@@ -256,16 +250,10 @@ bool ConnectionImpl::send(const Frame &frame)
     if (_state == state_closing || _state == state_closed) return false;
 
     // we need an output buffer
-    OutBuffer buffer(frame.totalSize());
-
-    // fill the buffer
-    frame.fill(buffer);
-
-    // append an end of frame byte (but not when still negotiating the protocol)
-    if (frame.needsSeparator()) buffer.add((uint8_t)206);
+    OutBuffer buffer(frame.buffer());
 
     // are we still setting up the connection?
-    if ((_state == state_connected && _queue.size() == 0) || frame.partOfHandshake())
+    if ((_state == state_connected && _queue.empty()) || frame.partOfHandshake())
     {
         // send the buffer
         _handler->onData(_parent, buffer.data(), buffer.size());
@@ -280,6 +268,32 @@ bool ConnectionImpl::send(const Frame &frame)
     return true;
 }
 
+/**
+ *  Send buffered data over the connection
+ *
+ *  @param  buffer      the buffer with data to send
+ */
+bool ConnectionImpl::send(OutBuffer &&buffer)
+{
+    // this only works when we are already connected
+    if (_state != state_connected) return false;
+
+    // are we waiting for other frames to be sent before us?
+    if (_queue.empty())
+    {
+        // send it directly
+        _handler->onData(_parent, buffer.data(), buffer.size());
+    }
+    else
+    {
+        // add to the list of waiting buffers
+        _queue.push(std::move(buffer));
+    }
+
+    // done
+    return true;
+}
+
 /**
  *  End of namspace
  */
diff --git a/src/exchangebindframe.h b/src/exchangebindframe.h
index e246fad..1d01161 100644
--- a/src/exchangebindframe.h
+++ b/src/exchangebindframe.h
@@ -1,6 +1,6 @@
 /**
  *  Exchangebindframe.h
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -26,25 +26,25 @@ private:
      *  @var ShortString
      */
     ShortString _destination;
-    
+
     /**
-     *  Exchange which is bound 
+     *  Exchange which is bound
      *  @var ShortString
      */
     ShortString _source;
-    
+
     /**
      *  Routing key
      *  @var ShortString
      */
     ShortString _routingKey;
-    
+
     /**
      *  contains: nowait  do not wait on response
      *  @var booleanset
      */
     BooleanSet _bools;
-    
+
     /**
      *  Additional arguments
      *  @var Table
@@ -61,7 +61,7 @@ protected:
     {
         // call base
         ExchangeFrame::fill(buffer);
-        
+
         buffer.add(_reserved);
         _destination.fill(buffer);
         _source.fill(buffer);
@@ -70,13 +70,13 @@ protected:
         _arguments.fill(buffer);
     }
 
-public: 
+public:
     /**
      *  Constructor based on incoming data
-     * 
+     *
      *  @param  frame   received frame to decode
      */
-    ExchangeBindFrame(ReceivedFrame &frame) : 
+    ExchangeBindFrame(ReceivedFrame &frame) :
         ExchangeFrame(frame),
         _reserved(frame.nextUint16()),
         _destination(frame),
@@ -102,8 +102,19 @@ public:
         _bools(noWait),
         _arguments(arguments)
     {}
-    
-    
+
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous when the nowait option has not been set
+        return !noWait();
+    }
+
     /**
      *  Get the destination exchange
      *  @return string
@@ -112,7 +123,7 @@ public:
     {
         return _destination;
     }
-    
+
     /**
      *  Get the source exchange
      *  @return string
@@ -121,7 +132,7 @@ public:
     {
         return _source;
     }
-    
+
     /**
      *  Get the routing key
      *  @return string
@@ -130,7 +141,7 @@ public:
     {
         return _routingKey;
     }
-    
+
     /**
      *  Get the method id
      *  @return uint16_t
@@ -139,7 +150,7 @@ public:
     {
         return 30;
     }
-    
+
     /**
      *  Get the additional arguments
      *  @return Table
@@ -148,12 +159,12 @@ public:
     {
         return _arguments;
     }
-    
+
     /**
      *  Get the nowait bool
      *  @return bool
      */
-    bool noWait()
+    bool noWait() const
     {
         return _bools.get(0);
     }
diff --git a/src/exchangebindokframe.h b/src/exchangebindokframe.h
index 5b1f29c..157d9e4 100644
--- a/src/exchangebindokframe.h
+++ b/src/exchangebindokframe.h
@@ -67,7 +67,7 @@ public:
         if(!channel) return false;
 
         // report to handler
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/exchangedeclareframe.h b/src/exchangedeclareframe.h
index 9f36e64..aa940dd 100644
--- a/src/exchangedeclareframe.h
+++ b/src/exchangedeclareframe.h
@@ -106,6 +106,18 @@ public:
      */
     virtual ~ExchangeDeclareFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  Method id
      *  @return uint16_t
diff --git a/src/exchangedeclareokframe.h b/src/exchangedeclareokframe.h
index f86bf3e..1938f73 100644
--- a/src/exchangedeclareokframe.h
+++ b/src/exchangedeclareokframe.h
@@ -70,7 +70,7 @@ public:
         if(!channel) return false;
 
         // report exchange declare ok
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/exchangedeleteframe.h b/src/exchangedeleteframe.h
index 960690c..cdd906f 100644
--- a/src/exchangedeleteframe.h
+++ b/src/exchangedeleteframe.h
@@ -83,6 +83,18 @@ public:
      */
     virtual ~ExchangeDeleteFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  returns the method id
      *  @return uint16_t
diff --git a/src/exchangedeleteokframe.h b/src/exchangedeleteokframe.h
index ce44336..b8ec41b 100644
--- a/src/exchangedeleteokframe.h
+++ b/src/exchangedeleteokframe.h
@@ -71,7 +71,7 @@ public:
         if(!channel) return false;
 
         // report to handler
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/exchangeunbindframe.h b/src/exchangeunbindframe.h
index 64999d2..d92d941 100644
--- a/src/exchangeunbindframe.h
+++ b/src/exchangeunbindframe.h
@@ -8,7 +8,7 @@
  *  Set up namespace
  */
 namespace AMQP {
-    
+
 /**
  *  Class definition
  */
@@ -26,31 +26,31 @@ private:
      *  @var ShortString
      */
     ShortString _destination;
-    
+
     /**
-     *  Exchange which is bound 
+     *  Exchange which is bound
      *  @var ShortString
      */
     ShortString _source;
-    
+
     /**
      *  Routing key
      *  @var ShortString
      */
     ShortString _routingKey;
-    
+
     /**
      *  contains: nowait  do not wait on response
      *  @var booleanset
      */
     BooleanSet _bools;
-    
+
     /**
      *  Additional arguments
      *  @var Table
      */
     Table _arguments;
-  
+
 protected:
     /**
      *  Encode a frame on a string buffer
@@ -61,7 +61,7 @@ protected:
     {
         // call base
         ExchangeFrame::fill(buffer);
-        
+
         buffer.add(_reserved);
         _destination.fill(buffer);
         _source.fill(buffer);
@@ -73,10 +73,10 @@ protected:
 public:
     /**
      *  Constructor based on incoming data
-     * 
+     *
      *  @param  frame   received frame to decode
      */
-    ExchangeUnbindFrame(ReceivedFrame &frame) : 
+    ExchangeUnbindFrame(ReceivedFrame &frame) :
         ExchangeFrame(frame),
         _reserved(frame.nextUint16()),
         _destination(frame),
@@ -102,8 +102,19 @@ public:
         _bools(noWait),
         _arguments(arguments)
     {}
-    
-    
+
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  Get the destination exchange
      *  @return string
@@ -112,7 +123,7 @@ public:
     {
         return _destination;
     }
-    
+
     /**
      *  Get the source exchange
      *  @return string
@@ -121,7 +132,7 @@ public:
     {
         return _source;
     }
-    
+
     /**
      *  Get the routing key
      *  @return string
@@ -130,7 +141,7 @@ public:
     {
         return _routingKey;
     }
-    
+
     /**
      *  Get the method id
      *  @return uint16_t
@@ -139,7 +150,7 @@ public:
     {
         return 40;
     }
-    
+
     /**
      *  Get the additional arguments
      *  @return Table
@@ -148,16 +159,16 @@ public:
     {
         return _arguments;
     }
-    
+
     /**
      *  Get the nowait bool
      *  @return bool
      */
-    bool noWait()
+    bool noWait() const
     {
         return _bools.get(0);
     }
-    
+
 };
 // leave namespace
 }
diff --git a/src/exchangeunbindokframe.h b/src/exchangeunbindokframe.h
index ea256ab..d25e2a1 100644
--- a/src/exchangeunbindokframe.h
+++ b/src/exchangeunbindokframe.h
@@ -68,7 +68,7 @@ public:
         if(!channel) return false;
 
         // report to handler
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/frame.h b/src/frame.h
index ed8ad0a..2522e7c 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1,9 +1,9 @@
 /**
  *  Frame.h
- * 
+ *
  *  Base class for frames. This base class can not be constructed from outside
  *  the library, and is only used internally.
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -11,7 +11,7 @@
  *  Set up namespace
  */
 namespace AMQP {
-    
+
 /**
  *  Class definition
  */
@@ -19,11 +19,11 @@ class Frame
 {
 protected:
     /**
-     *  Protected constructor to ensure that no objects are created from 
+     *  Protected constructor to ensure that no objects are created from
      *  outside the library
      */
     Frame() {}
-    
+
 public:
     /**
      *  Destructor
@@ -35,40 +35,67 @@ public:
      *  @return uint32_t
      */
     virtual uint32_t totalSize() const = 0;
-    
+
     /**
      *  Fill an output buffer
      *  @param  buffer
      */
     virtual void fill(OutBuffer &buffer) const = 0;
-    
+
     /**
      *  Is this a frame that is part of the connection setup?
      *  @return bool
      */
     virtual bool partOfHandshake() const { return false; }
-    
+
     /**
      *  Does this frame need an end-of-frame seperator?
      *  @return bool
      */
     virtual bool needsSeparator() const { return true; }
-    
+
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    virtual bool synchronous() const { return false; }
+
+    /**
+     *  Retrieve the buffer in AMQP wire-format for
+     *  sending over the socket connection
+     */
+    OutBuffer buffer() const
+    {
+        // we need an output buffer
+        OutBuffer buffer(totalSize());
+
+        // fill the buffer
+        fill(buffer);
+
+        // append an end of frame byte (but not when still negotiating the protocol)
+        if (needsSeparator()) buffer.add((uint8_t)206);
+
+        // return the created buffer
+        return buffer;
+    }
+
     /**
      *  Process the frame
      *  @param  connection      The connection over which it was received
      *  @return bool            Was it succesfully processed?
      */
-    virtual bool process(ConnectionImpl *connection) 
+    virtual bool process(ConnectionImpl *connection)
     {
         // this is an exception
         throw ProtocolException("unimplemented frame");
-        
+
         // unreachable
         return false;
     }
 };
-    
+
 /**
  *  End of namespace
  */
diff --git a/src/methodframe.h b/src/methodframe.h
index c435df7..eac62b5 100644
--- a/src/methodframe.h
+++ b/src/methodframe.h
@@ -49,6 +49,14 @@ public:
      */
     virtual ~MethodFrame() {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override { return true; }
+
     /**
      *  Get the message type
      *  @return uint8_t
diff --git a/src/queuebindframe.h b/src/queuebindframe.h
index 93b30c6..bc4d2e9 100644
--- a/src/queuebindframe.h
+++ b/src/queuebindframe.h
@@ -110,6 +110,18 @@ public:
         _arguments(frame)
     {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  Returns the method id
      *  @return uint16_t
diff --git a/src/queuebindokframe.h b/src/queuebindokframe.h
index 1d55a33..bf27b87 100644
--- a/src/queuebindokframe.h
+++ b/src/queuebindokframe.h
@@ -69,7 +69,7 @@ public:
         if(!channel) return false;
 
         // report to handler
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/queuedeclareframe.h b/src/queuedeclareframe.h
index 214cd48..475c8b6 100644
--- a/src/queuedeclareframe.h
+++ b/src/queuedeclareframe.h
@@ -98,6 +98,18 @@ public:
         _arguments(frame)
     {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  returns the method id
      *  @return string
@@ -156,7 +168,7 @@ public:
      *  returns whether to  wait for a response
      *  @return bool
      */
-    bool noWait()
+    bool noWait() const
     {
         return _bools.get(4);
     }
diff --git a/src/queuedeclareokframe.h b/src/queuedeclareokframe.h
index eb660d8..852c4ec 100644
--- a/src/queuedeclareokframe.h
+++ b/src/queuedeclareokframe.h
@@ -133,7 +133,7 @@ public:
         if (!channel) return false;
 
         // report success
-        channel->reportSuccess(name(), messageCount(), consumerCount());
+        if (channel->reportSuccess(name(), messageCount(), consumerCount())) channel->synchronized();
 
         // done
         return true;
diff --git a/src/queuedeleteframe.h b/src/queuedeleteframe.h
index 8892c5e..dc9a00a 100644
--- a/src/queuedeleteframe.h
+++ b/src/queuedeleteframe.h
@@ -85,6 +85,18 @@ public:
         _bools(frame)
     {}
 
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  returns the method id
      *  @returns uint16_t
diff --git a/src/queuedeleteokframe.h b/src/queuedeleteokframe.h
index 39cd9b5..c214aa3 100644
--- a/src/queuedeleteokframe.h
+++ b/src/queuedeleteokframe.h
@@ -94,7 +94,7 @@ public:
         if(!channel) return false;
 
         // report queue deletion success
-        channel->reportSuccess(this->messageCount());
+        if (channel->reportSuccess(this->messageCount())) channel->synchronized();
 
         // done
         return true;
diff --git a/src/queuepurgeframe.h b/src/queuepurgeframe.h
index e2a45b2..08cfad5 100644
--- a/src/queuepurgeframe.h
+++ b/src/queuepurgeframe.h
@@ -1,6 +1,6 @@
 /**
  *  Class describing an AMQP queue purge frame
- * 
+ *
  *  @copyright 2014 Copernica BV
  */
 
@@ -27,7 +27,7 @@ private:
     ShortString _name;
 
     /**
-     *  Do not wait on response 
+     *  Do not wait on response
      *  @var BooleanSet
      */
     BooleanSet _noWait;
@@ -37,7 +37,7 @@ protected:
      *  Encode the frame into a buffer
      *
      *  @param   buffer  buffer to write frame to
-     */ 
+     */
     virtual void fill(OutBuffer& buffer) const override
     {
         // call base
@@ -63,13 +63,13 @@ public:
      *  @param   noWait  Do not wait on response
      *
      *  @return  newly created Queuepurgeframe
-     */ 
+     */
     QueuePurgeFrame(uint16_t channel, const std::string& name, bool noWait = false) :
         QueueFrame(channel, name.length() + 4), // 1 extra for string length, 1 for bool, 2 for deprecated field
         _name(name),
         _noWait(noWait)
     {}
-    
+
     /**
      *  Constructor based on received data
      *  @param frame    received frame
@@ -80,11 +80,23 @@ public:
         _name(frame),
         _noWait(frame)
     {}
-    
+
+    /**
+     *  Is this a synchronous frame?
+     *
+     *  After a synchronous frame no more frames may be
+     *  sent until the accompanying -ok frame arrives
+     */
+    bool synchronous() const override
+    {
+        // we are synchronous without the nowait option
+        return !noWait();
+    }
+
     /**
      *  The method ID
      *  @return method id
-     */ 
+     */
     virtual uint16_t methodID() const override
     {
         return 30;
diff --git a/src/queuepurgeokframe.h b/src/queuepurgeokframe.h
index 166cb60..aaa939d 100644
--- a/src/queuepurgeokframe.h
+++ b/src/queuepurgeokframe.h
@@ -94,7 +94,7 @@ public:
         if(!channel) return false;
 
         // report queue purge success
-        channel->reportSuccess(this->messageCount());
+        if (channel->reportSuccess(this->messageCount())) channel->synchronized();
 
         // done
         return true;
diff --git a/src/queueunbindokframe.h b/src/queueunbindokframe.h
index 14a2761..cdcb570 100644
--- a/src/queueunbindokframe.h
+++ b/src/queueunbindokframe.h
@@ -73,7 +73,7 @@ public:
         if(!channel) return false;
 
         // report queue unbind success
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/transactioncommitokframe.h b/src/transactioncommitokframe.h
index 27f7004..3993a8f 100644
--- a/src/transactioncommitokframe.h
+++ b/src/transactioncommitokframe.h
@@ -74,7 +74,7 @@ public:
         if(!channel) return false;
 
         // report that the channel is open
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/transactionrollbackokframe.h b/src/transactionrollbackokframe.h
index e87d893..868626b 100644
--- a/src/transactionrollbackokframe.h
+++ b/src/transactionrollbackokframe.h
@@ -74,7 +74,7 @@ public:
         if(!channel) return false;
 
         // report that the channel is open
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;
diff --git a/src/transactionselectokframe.h b/src/transactionselectokframe.h
index 8a842f7..b66aede 100644
--- a/src/transactionselectokframe.h
+++ b/src/transactionselectokframe.h
@@ -74,7 +74,7 @@ public:
         if(!channel) return false;
 
         // report that the channel is open
-        channel->reportSuccess();
+        if (channel->reportSuccess()) channel->synchronized();
 
         // done
         return true;

From 7084d49b13e5a334a5daae8be4e1ecf084cbfd5c Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Tue, 29 Apr 2014 16:07:43 +0200
Subject: [PATCH 38/41] Updated README

---
 README.md | 152 ++++++++++++++++++++++++++----------------------------
 1 file changed, 74 insertions(+), 78 deletions(-)

diff --git a/README.md b/README.md
index ddc6605..cef887d 100644
--- a/README.md
+++ b/README.md
@@ -86,8 +86,8 @@ class MyConnectionHandler : public AMQP::ConnectionHandler
     }
 
     /**
-     *  Method that is called when the connection was closed. This is the 
-     *  counter part of a call to Connection::close() and it confirms that the 
+     *  Method that is called when the connection was closed. This is the
+     *  counter part of a call to Connection::close() and it confirms that the
      *  connection was correctly closed.
      *
      *  @param  connection      The connection that was closed and that is now unusable
@@ -143,12 +143,12 @@ every time that it wants to send out data. We've explained that it is up to you
 implement that method. But what about data in the other direction? How does the
 library receive data back from RabbitMQ?
 
-The AMQP-CPP library does not do any IO by itself and it is therefore of course 
-also not possible for the library to receive data from a socket. It is again up 
-to you to do this. If, for example, you notice in your event loop that the socket 
-that is connected with the RabbitMQ server becomes readable, you should read out 
-that socket (for example by using the recv() system call), and pass the received 
-bytes to the AMQP-CPP library. This is done by calling the parse() method in the 
+The AMQP-CPP library does not do any IO by itself and it is therefore of course
+also not possible for the library to receive data from a socket. It is again up
+to you to do this. If, for example, you notice in your event loop that the socket
+that is connected with the RabbitMQ server becomes readable, you should read out
+that socket (for example by using the recv() system call), and pass the received
+bytes to the AMQP-CPP library. This is done by calling the parse() method in the
 Connection object.
 
 The Connection::parse() method gets two parameters, a pointer to a buffer of
@@ -160,12 +160,12 @@ The code snippet below comes from the Connection.h C++ header file.
  *  Parse data that was recevied from RabbitMQ
  *
  *  Every time that data comes in from RabbitMQ, you should call this method to parse
- *  the incoming data, and let it handle by the AMQP-CPP library. This method returns 
+ *  the incoming data, and let it handle by the AMQP-CPP library. This method returns
  *  the number of bytes that were processed.
  *
- *  If not all bytes could be processed because it only contained a partial frame, 
- *  you should call this same method later on when more data is available. The 
- *  AMQP-CPP library does not do any buffering, so it is up to the caller to ensure 
+ *  If not all bytes could be processed because it only contained a partial frame,
+ *  you should call this same method later on when more data is available. The
+ *  AMQP-CPP library does not do any buffering, so it is up to the caller to ensure
  *  that the old data is also passed in that later call.
  *
  *  @param  buffer      buffer to decode
@@ -178,10 +178,10 @@ size_t parse(char *buffer, size_t size)
 }
 ````
 
-You should do all the book keeping for the buffer yourselves. If you for example 
-call the Connection::parse() method with a buffer of 100 bytes, and the method 
-returns that only 60 bytes were processed, you should later call the method again, 
-with a buffer filled with the remaining 40 bytes. If the method returns 0, you should 
+You should do all the book keeping for the buffer yourselves. If you for example
+call the Connection::parse() method with a buffer of 100 bytes, and the method
+returns that only 60 bytes were processed, you should later call the method again,
+with a buffer filled with the remaining 40 bytes. If the method returns 0, you should
 make a new call to parse() when more data is available, with a buffer that contains
 both the old data, and the new data.
 
@@ -189,8 +189,8 @@ both the old data, and the new data.
 CHANNELS
 ========
 
-In the example we created a channel object. A channel is a virtual connection over 
-a single TCP connection, and it is possible to create many channels that all use 
+In the example we created a channel object. A channel is a virtual connection over
+a single TCP connection, and it is possible to create many channels that all use
 the same TCP connection.
 
 AMQP instructions are always sent over a channel, so before you can send the first
@@ -203,21 +203,21 @@ documented.
 
 The constructor of the Channel object accepts one parameter: the connection object.
 Unlike the connection it does not accept a handler. Instead of a handler object,
-(almost) every method of the Channel class returns an instance of the 'Deferred' 
-class. This object can be used to install handlers that will be called in case 
+(almost) every method of the Channel class returns an instance of the 'Deferred'
+class. This object can be used to install handlers that will be called in case
 of success or failure.
 
-For example, if you call the channel.declareExchange() method, the AMQP-CPP library 
+For example, if you call the channel.declareExchange() method, the AMQP-CPP library
 will send a message to the RabbitMQ message broker to ask it to declare the
 queue. However, because all operations in the library are asynchronous, the
 declareExchange() method can not return 'true' or 'false' to inform you whether
-the operation was succesful or not. Only after a while, after the instruction 
-has reached the RabbitMQ server, and the confirmation from the server has been 
+the operation was succesful or not. Only after a while, after the instruction
+has reached the RabbitMQ server, and the confirmation from the server has been
 sent back to the client, the library can report the result of the declareExchange()
 call.
 
-To prevent any blocking calls, the channel.declareExchange() method returns a 
-'Deferred' result object, on which you can set callback functions that will be 
+To prevent any blocking calls, the channel.declareExchange() method returns a
+'Deferred' result object, on which you can set callback functions that will be
 called when the operation succeeds or fails.
 
 ````c++
@@ -249,9 +249,9 @@ run in either case: when the operation succeeds or when it fails.
 
 The signature for the onError() method is always the same: it gets one parameter
 with a human readable error message. The onSuccess() function has a different
-signature depending on the method that you call. Most onSuccess() functions 
-(like the one we showed for the declareExchange() method) do not get any 
-parameters at all. Some specific onSuccess callbacks receive extra parameters 
+signature depending on the method that you call. Most onSuccess() functions
+(like the one we showed for the declareExchange() method) do not get any
+parameters at all. Some specific onSuccess callbacks receive extra parameters
 with additional information.
 
 
@@ -287,7 +287,7 @@ myChannel.onReady([]() {
 });
 ````
 
-In theory, you should wait for the onReady() callback to be called before you 
+In theory, you should wait for the onReady() callback to be called before you
 send any other instructions over the channel. In practice however, the AMQP library
 caches all instructions that were sent too early, so that you can use the
 channel object right after it was constructed.
@@ -307,10 +307,10 @@ myChannel.declareQueue("my-queue");
 myChannel.declareExchange("my-exchange");
 ````
 
-If the first declareQueue() call fails in the example above, the second 
+If the first declareQueue() call fails in the example above, the second
 myChannel.declareExchange() method will not be executed, even when this
 second instruction was already sent to the server. The second instruction will be
-ignored by the RabbitMQ server because the channel was already in an invalid 
+ignored by the RabbitMQ server because the channel was already in an invalid
 state after the first failure.
 
 You can overcome this by using multiple channels:
@@ -322,10 +322,10 @@ channel1.declareQueue("my-queue");
 channel2.declareExchange("my-exchange");
 ````
 
-Now, if an error occurs with declaring the queue, it will not have consequences 
-for the other call. But this comes at a small price: setting up the extra channel 
-requires and extra instruction to be sent to the RabbitMQ server, so some extra 
-bytes are sent over the network, and some additional resources in both the client 
+Now, if an error occurs with declaring the queue, it will not have consequences
+for the other call. But this comes at a small price: setting up the extra channel
+requires and extra instruction to be sent to the RabbitMQ server, so some extra
+bytes are sent over the network, and some additional resources in both the client
 application and the RabbitMQ server are used (although this is all very limited).
 
 
@@ -385,9 +385,9 @@ channel.declareQueue("myQueue").onSuccess(callback);
 ````
 
 Just like many others methods in the Channel class, the declareQueue() method
-accept an integer parameter named 'flags'. This is a variable in which you can 
-set method-specific options, by summing up all the options that are described in 
-the documentation above the method. If you for example want to create a durable, 
+accept an integer parameter named 'flags'. This is a variable in which you can
+set method-specific options, by summing up all the options that are described in
+the documentation above the method. If you for example want to create a durable,
 auto-deleted queue, you can pass in the value AMQP::durable + AMQP::autodelete.
 
 The declareQueue() method also accepts a parameter named 'arguments', which is of type
@@ -421,7 +421,7 @@ exchange to publish to, the routing key to use, and the actual message that
 you're publishing - all these parameters are standard C++ strings.
 
 More extended versions of the publish() method exist that accept additional
-arguments, and that enable you to publish entire Envelope objects. An envelope 
+arguments, and that enable you to publish entire Envelope objects. An envelope
 is an object that contains the message plus a list of optional meta information like
 the content-type, content-encoding, priority, expire time and more. None of these
 meta fields are interpreted by this library, and also the RabbitMQ ignores most
@@ -441,10 +441,10 @@ in almost any form:
  *
  *  The following flags can be used
  *
- *      -   mandatory   if set, an unroutable message will be reported to the 
+ *      -   mandatory   if set, an unroutable message will be reported to the
  *                      channel handler with the onReturned method
- * 
- *      -   immediate   if set, a message that could not immediately be consumed 
+ *
+ *      -   immediate   if set, a message that could not immediately be consumed
  *                      is returned to the onReturned method
  *
  *  If either of the two flags is set, and the message could not immediately
@@ -469,17 +469,17 @@ bool publish(const std::string &exchange, const std::string &routingKey, const c
 
 Published messages are normally not confirmed by the server, and the RabbitMQ
 will not send a report back to inform us whether the message was succesfully
-published or not. Therefore the publish method does also not return a Deferred 
+published or not. Therefore the publish method does also not return a Deferred
 object.
 
-As long as no error is reported via the Channel::onError() method, you can safely 
+As long as no error is reported via the Channel::onError() method, you can safely
 assume that your messages were delivered.
 
-This can of course be a problem when you are publishing many messages. If you get 
-an error halfway through there is no way to know for sure how many messages made 
-it to the broker and how many should be republished. If this is important, you can 
+This can of course be a problem when you are publishing many messages. If you get
+an error halfway through there is no way to know for sure how many messages made
+it to the broker and how many should be republished. If this is important, you can
 wrap the publish commands inside a transaction. In this case, if an error occurs,
-the transaction is automatically rolled back by RabbitMQ and none of the messages 
+the transaction is automatically rolled back by RabbitMQ and none of the messages
 are actually published.
 
 ````c++
@@ -531,21 +531,17 @@ The full documentation from the C++ Channel.h headerfile looks like this:
  *
  *  The following flags are supported:
  *
- *      -   nolocal             if set, messages published on this channel are 
+ *      -   nolocal             if set, messages published on this channel are
  *                              not also consumed
  *
- *      -   noack               if set, consumed messages do not have to be acked, 
+ *      -   noack               if set, consumed messages do not have to be acked,
  *                              this happens automatically
  *
- *      -   exclusive           request exclusive access, only this consumer can 
+ *      -   exclusive           request exclusive access, only this consumer can
  *                              access the queue
  *
- *      -   nowait              the server does not have to send a response back 
- *                              that consuming is active
- *
  *  The method ChannelHandler::onConsumerStarted() will be called when the
- *  consumer has started (unless the nowait option was set, in which case
- *  no confirmation method is called)
+ *  consumer has started.
  *
  *  @param  queue               the queue from which you want to consume
  *  @param  tag                 a consumer tag that will be associated with this consume operation
@@ -561,14 +557,14 @@ DeferredConsumer &consume(const std::string &queue, int flags = 0);
 DeferredConsumer &consume(const std::string &queue, const AMQP::Table &arguments);
 ````
 
-As you can see, the consume method returns a DeferredConsumer. This object is a 
-regular Deferred, with  additions. The onSuccess() method of a 
+As you can see, the consume method returns a DeferredConsumer. This object is a
+regular Deferred, with  additions. The onSuccess() method of a
 DeferredConsumer is slightly different than the onSuccess() method of a regular
 Deferred object: one extra parameter will be supplied to your callback function
 with the consumer tag.
 
 The onSuccess() callback will be called when the consume operation _has started_,
-but not when messages are actually consumed. For this you will have to install 
+but not when messages are actually consumed. For this you will have to install
 a different callback, using the onReceived() method.
 
 ````c++
@@ -588,7 +584,7 @@ auto errorCb = [](const char *message) {
 auto messageCb = [&channel](const AMQP::Message &message, uint64_t deliveryTag, bool redelivered) {
 
     std::cout << "message received" << std::endl;
-    
+
     // acknowledge the message
     channel.ack(deliveryTag);
 }
@@ -601,33 +597,33 @@ channel.consume("my-queue")
 
 ````
 
-The Message object holds all information of the delivered message: the actual 
-content, all meta information from the envelope (in fact, the Message class is 
-derived from the Envelope class), and even the name of the exchange and the 
-routing key that were used when the message was originally published. For a full 
+The Message object holds all information of the delivered message: the actual
+content, all meta information from the envelope (in fact, the Message class is
+derived from the Envelope class), and even the name of the exchange and the
+routing key that were used when the message was originally published. For a full
 list of all information in the Message class, you best have a look at the
 message.h, envelope.h and metadata.h header files.
 
-Another important parameter to the onReceived() method is the deliveryTag parameter. 
-This is a unique identifier that you need to acknowledge an incoming message. 
-RabbitMQ only removes the message after it has been acknowledged, so that if your 
-application crashes while it was busy processing the message, the message does 
-not get lost but remains in the queue. But this means that after you've processed 
-the message, you must inform RabbitMQ about it by calling the Channel:ack() method. 
+Another important parameter to the onReceived() method is the deliveryTag parameter.
+This is a unique identifier that you need to acknowledge an incoming message.
+RabbitMQ only removes the message after it has been acknowledged, so that if your
+application crashes while it was busy processing the message, the message does
+not get lost but remains in the queue. But this means that after you've processed
+the message, you must inform RabbitMQ about it by calling the Channel:ack() method.
 This method is very simple and takes in its simplest form only one parameter: the
 deliveryTag of the message.
 
-Consuming messages is a continuous process. RabbitMQ keeps sending messages, until 
-you stop the consumer, which can be done by calling the Channel::cancel() method. 
+Consuming messages is a continuous process. RabbitMQ keeps sending messages, until
+you stop the consumer, which can be done by calling the Channel::cancel() method.
 If you close the channel, or the entire TCP connection, consuming also stops.
 
-RabbitMQ throttles the number of messages that are delivered to you, to prevent 
-that your application is flooded with messages from the queue, and to spread out 
-the messages over multiple consumers. This is done with a setting called 
-quality-of-service (QOS). The QOS setting is a numeric value which holds the number 
+RabbitMQ throttles the number of messages that are delivered to you, to prevent
+that your application is flooded with messages from the queue, and to spread out
+the messages over multiple consumers. This is done with a setting called
+quality-of-service (QOS). The QOS setting is a numeric value which holds the number
 of unacknowledged messages that you are allowed to have. RabbitMQ stops sending
-additional messages when the number of unacknowledges messages has reached this 
-limit, and only sends additional messages when an earlier message gets acknowledged. 
+additional messages when the number of unacknowledges messages has reached this
+limit, and only sends additional messages when an earlier message gets acknowledged.
 To change the QOS, you can simple call Channel::setQos().
 
 

From ca8a39ea4542b3885023e32a0a7f85f2db626300 Mon Sep 17 00:00:00 2001
From: Martijn Otto <martijn.otto@copernica.com>
Date: Tue, 6 May 2014 16:49:43 +0200
Subject: [PATCH 39/41] Fix memory leak

---
 include/deferred.h | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/include/deferred.h b/include/deferred.h
index d8fd257..01a3fe8 100644
--- a/include/deferred.h
+++ b/include/deferred.h
@@ -72,11 +72,11 @@ protected:
         // execute callbacks if registered
         if (_successCallback)   _successCallback();
         if (_finalizeCallback)  _finalizeCallback();
-        
+
         // return the next deferred result
         return _next;
     }
-    
+
     /**
      *  Report success for queue declared messages
      *  @param  name            Name of the new queue
@@ -89,7 +89,7 @@ protected:
         // this is the same as a regular success message
         return reportSuccess();
     }
-    
+
     /**
      *  Report success for frames that report delete operations
      *  @param  messagecount    Number of messages that were deleted
@@ -100,7 +100,7 @@ protected:
         // this is the same as a regular success message
         return reportSuccess();
     }
-    
+
     /**
      *  Report success for frames that report cancel operations
      *  @param  name            Consumer tag that is cancelled
@@ -117,15 +117,15 @@ protected:
      *  @param  error           Description of the error that occured
      *  @return Deferred        Next deferred result
      */
-    Deferred *reportError(const char *error) 
+    Deferred *reportError(const char *error)
     {
         // from this moment on the object should be listed as failed
         _failed = true;
-        
+
         // execute callbacks if registered
         if (_errorCallback)     _errorCallback(error);
         if (_finalizeCallback)  _finalizeCallback();
-        
+
         // return the next deferred result
         return _next;
     }
@@ -146,7 +146,7 @@ protected:
      */
     friend class ChannelImpl;
     friend class Callbacks;
-    
+
 protected:
     /**
      *  Protected constructor that can only be called
@@ -163,6 +163,11 @@ public:
     Deferred(const Deferred &that) = delete;
     Deferred(Deferred &&that) = delete;
 
+    /**
+     *  Destructor
+     */
+    virtual ~Deferred() {}
+
     /**
      *  Cast to a boolean
      */
@@ -186,7 +191,7 @@ public:
     {
         // store callback
         _successCallback = callback;
-        
+
         // allow chaining
         return *this;
     }
@@ -208,7 +213,7 @@ public:
 
         // if the object is already in a failed state, we call the callback right away
         if (_failed) callback("Frame could not be sent");
-        
+
         // allow chaining
         return *this;
     }
@@ -232,10 +237,10 @@ public:
     {
         // store callback
         _finalizeCallback = callback;
-        
+
         // if the object is already in a failed state, we call the callback right away
         if (_failed) callback();
-        
+
         // allow chaining
         return *this;
     }

From 3a700226c8b18fff7c0f6dadc4b7885f9fe52c37 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Mon, 26 May 2014 18:17:49 +0200
Subject: [PATCH 40/41] BasicNack frame makes the consumer stop (dont know why)
 so we use the BackReject message instead when there is no need to reject
 multiple messages

---
 src/channelimpl.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 0b917f4..0f6171d 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -36,6 +36,7 @@
 #include "basicackframe.h"
 #include "basicnackframe.h"
 #include "basicrecoverframe.h"
+#include "basicrejectframe.h"
 
 /**
  *  Set up namespace
@@ -555,8 +556,17 @@ bool ChannelImpl::ack(uint64_t deliveryTag, int flags)
  */
 bool ChannelImpl::reject(uint64_t deliveryTag, int flags)
 {
-    // send a nack frame
-    return send(BasicNackFrame(_id, deliveryTag, flags & multiple, flags & requeue));
+    // should we reject multiple messages?
+    if (flags & multiple)
+    {
+        // send a nack frame
+        return send(BasicNackFrame(_id, deliveryTag, true, flags & requeue));
+    }
+    else
+    {
+        // send a reject frame
+        return send(BasicRejectFrame(_id, deliveryTag, flags & requeue));
+    }
 }
 
 /**

From 850252e1ddce9ac05569f7a3fb7436c31d927ac2 Mon Sep 17 00:00:00 2001
From: Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
Date: Fri, 25 Jul 2014 09:34:01 +0200
Subject: [PATCH 41/41] link time optimization only for static libs

---
 src/Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Makefile b/src/Makefile
index 4f0baa2..c9330b9 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,6 +1,6 @@
 CPP			    = g++
 RM			    = rm -f
-CPPFLAGS		= -Wall -c -I. -g -flto -std=c++11 -g
+CPPFLAGS		= -Wall -c -I. -g -std=c++11 -g
 LD			    = g++
 LD_FLAGS		= -Wall -shared -O2
 SHARED_LIB		= libamqpcpp.so
@@ -25,7 +25,7 @@ clean:
 	${RM} *.obj *~* ${SHARED_OBJECTS} ${STATIC_OBJECTS} ${SHARED_LIB} ${STATIC_LIB}
 
 ${SHARED_OBJECTS}:
-	${CPP} ${CPPFLAGS} -fpic -o $@ ${@:%.o=%.cpp}
+	${CPP} ${CPPFLAGS} -flto -fpic -o $@ ${@:%.o=%.cpp}
 
 ${STATIC_OBJECTS}:
 	${CPP} ${CPPFLAGS} -o $@ ${@:%.s.o=%.cpp}