diff --git a/README.md b/README.md
index 8e9cc63..b21c307 100644
--- a/README.md
+++ b/README.md
@@ -935,7 +935,7 @@ auto callback = [](const std::string &name, int msgcount, int consumercount) {
 };
 
 // declare the queue, and install the callback that is called on success
-channel.declareQueue("myQueue").onSuccess(callback);
+channel.declareQueue("myQueue").onSuccess(std::move(callback));
 ````
 
 Just like many others methods in the Channel class, the declareQueue() method
diff --git a/include/amqpcpp/channel.h b/include/amqpcpp/channel.h
index 0bfd2b9..836e13d 100644
--- a/include/amqpcpp/channel.h
+++ b/include/amqpcpp/channel.h
@@ -76,10 +76,11 @@ public:
      *  times will remove the old callback.
      *
      *  @param  callback    the callback to execute
-     */
-    void onReady(const SuccessCallback &callback)
+     */         
+    inline void onReady(const SuccessCallback& callback) { return onReady(SuccessCallback(callback)); }
+    void onReady(SuccessCallback&& callback)
     {
-        _implementation->onReady(callback);
+        _implementation->onReady(std::move(callback));
     }
 
     /**
@@ -90,9 +91,10 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    void onError(const ErrorCallback &callback)
+    inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
+    void onError(ErrorCallback&& callback)
     {
-        _implementation->onError(callback);
+        _implementation->onError(std::move(callback));
     }
 
     /**
diff --git a/include/amqpcpp/channelimpl.h b/include/amqpcpp/channelimpl.h
index 73bedc7..c487808 100644
--- a/include/amqpcpp/channelimpl.h
+++ b/include/amqpcpp/channelimpl.h
@@ -212,13 +212,14 @@ public:
      *  Callback that is called when the channel was succesfully created.
      *  @param  callback    the callback to execute
      */
-    void onReady(const SuccessCallback &callback)
+    inline void onReady(const SuccessCallback& callback) { return onReady(SuccessCallback(callback)); }
+    void onReady(SuccessCallback&& callback)
     {
         // store callback
-        _readyCallback = callback;
+        _readyCallback = std::move(callback);
 
         // direct call if channel is already ready
-        if (_state == state_ready && callback) callback();
+        if (_state == state_ready && _readyCallback) _readyCallback();
     }
 
     /**
@@ -229,7 +230,8 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    void onError(const ErrorCallback &callback);
+    inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
+    void onError(ErrorCallback&& callback);
 
     /**
      *  Pause deliveries on a channel
diff --git a/include/amqpcpp/deferred.h b/include/amqpcpp/deferred.h
index a5323df..03a5d5c 100644
--- a/include/amqpcpp/deferred.h
+++ b/include/amqpcpp/deferred.h
@@ -243,10 +243,11 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred &onSuccess(const SuccessCallback &callback)
+    inline Deferred &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    Deferred &onSuccess(SuccessCallback&& callback)
     {
         // store callback
-        _successCallback = callback;
+        _successCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -262,13 +263,14 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred &onError(const ErrorCallback &callback)
+    inline Deferred &onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
+    Deferred &onError(ErrorCallback&& callback)
     {
         // store callback
-        _errorCallback = callback;
+        _errorCallback = std::move(callback);
 
         // if the object is already in a failed state, we call the callback right away
-        if (_failed) callback("Frame could not be sent");
+        if (_failed) _errorCallback("Frame could not be sent");
 
         // allow chaining
         return *this;
@@ -289,13 +291,14 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    Deferred &onFinalize(const FinalizeCallback &callback)
+    inline Deferred &onFinalize(const FinalizeCallback& callback) { return onFinalize(FinalizeCallback(callback)); }
+    Deferred &onFinalize(FinalizeCallback&& callback)
     {
         // if the object is already in a failed state, we call the callback right away
         if (_failed) callback();
 
         // otherwise we store callback until it's time for the call
-        else _finalizeCallback = callback;
+        else _finalizeCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredcancel.h b/include/amqpcpp/deferredcancel.h
index 7bcaed6..fd701ee 100644
--- a/include/amqpcpp/deferredcancel.h
+++ b/include/amqpcpp/deferredcancel.h
@@ -74,10 +74,11 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    DeferredCancel &onSuccess(const CancelCallback &callback)
+    inline DeferredCancel &onSuccess(const CancelCallback& callback) { return onSuccess(CancelCallback(callback)); }
+    DeferredCancel &onSuccess(CancelCallback&& callback)
     {
         // store callback
-        _cancelCallback = callback;
+        _cancelCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -87,10 +88,11 @@ public:
      *  Register the function that is called when the cancel operation succeeded
      *  @param  callback
      */
-    DeferredCancel &onSuccess(const SuccessCallback &callback)
+    inline DeferredCancel &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    DeferredCancel &onSuccess(SuccessCallback&& callback)
     {
         // call base
-        Deferred::onSuccess(callback);
+        Deferred::onSuccess(std::move(callback));
         
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredconfirm.h b/include/amqpcpp/deferredconfirm.h
index fc89a06..3dfddcf 100644
--- a/include/amqpcpp/deferredconfirm.h
+++ b/include/amqpcpp/deferredconfirm.h
@@ -76,10 +76,11 @@ public:
      *  confirmed mode
      *  @param  callback
      */
-    DeferredConfirm &onSuccess(const SuccessCallback &callback)
+    inline DeferredConfirm &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    DeferredConfirm &onSuccess(SuccessCallback&& callback)
     {
         // call base
-        Deferred::onSuccess(callback);
+        Deferred::onSuccess(std::move(callback));
 
         // allow chaining
         return *this;
@@ -89,10 +90,11 @@ public:
      *  Callback that is called when the broker confirmed message publication
      *  @param  callback    the callback to execute
      */
-    DeferredConfirm &onAck(const AckCallback &callback)
+    inline DeferredConfirm &onAck(const AckCallback& callback) { return onAck(AckCallback(callback)); }
+    DeferredConfirm &onAck(AckCallback&& callback)
     {
         // store callback
-        _ackCallback = callback;
+        _ackCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -102,10 +104,11 @@ public:
      *  Callback that is called when the broker denied message publication
      *  @param  callback    the callback to execute
      */
-    DeferredConfirm &onNack(const NackCallback &callback)
+    inline DeferredConfirm &onNack(const NackCallback& callback) { return onNack(NackCallback(callback)); }
+    DeferredConfirm &onNack(NackCallback&& callback)
     {
         // store callback
-        _nackCallback = callback;
+        _nackCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredconsumer.h b/include/amqpcpp/deferredconsumer.h
index c8030e7..40626c0 100644
--- a/include/amqpcpp/deferredconsumer.h
+++ b/include/amqpcpp/deferredconsumer.h
@@ -87,10 +87,11 @@ public:
      *  that you need to later stop the consumer
      *  @param  callback
      */
-    DeferredConsumer &onSuccess(const ConsumeCallback &callback)
+    inline DeferredConsumer &onSuccess(const ConsumeCallback& callback) { return onSuccess(ConsumeCallback(callback)); }
+    DeferredConsumer &onSuccess(ConsumeCallback&& callback)
     {
         // store the callback
-        _consumeCallback = callback;
+        _consumeCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -102,10 +103,11 @@ public:
      *  since that will also pass the consumer-tag as parameter.
      *  @param  callback
      */
-    DeferredConsumer &onSuccess(const SuccessCallback &callback)
+    inline DeferredConsumer &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    DeferredConsumer &onSuccess(SuccessCallback&& callback)
     {
         // call base
-        Deferred::onSuccess(callback);
+        Deferred::onSuccess(std::move(std::move(callback)));
 
         // allow chaining
         return *this;
@@ -115,10 +117,11 @@ public:
      *  Register a function to be called when a full message is received
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer &onReceived(const MessageCallback &callback)
+    inline DeferredConsumer &onReceived(const MessageCallback& callback) { return onReceived(MessageCallback(callback)); }
+    DeferredConsumer &onReceived(MessageCallback&& callback)
     {
         // store callback
-        _messageCallback = callback;
+        _messageCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -128,10 +131,11 @@ public:
      *  Alias for onReceived() (see above)
      *  @param  callback    the callback to execute
      */
-    DeferredConsumer &onMessage(const MessageCallback &callback)
+    inline DeferredConsumer &onMessage(const MessageCallback& callback) { return onMessage(MessageCallback(callback)); }
+    DeferredConsumer &onMessage(MessageCallback&& callback)
     {
         // store callback
-        _messageCallback = callback;
+        _messageCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -166,10 +170,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredConsumer &onBegin(const StartCallback &callback)
+    inline DeferredConsumer &onBegin(const StartCallback& callback) { return onBegin(StartCallback(callback)); }
+    DeferredConsumer &onBegin(StartCallback&& callback)
     {
         // store callback
-        _startCallback = callback;
+        _startCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -182,10 +187,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredConsumer &onStart(const StartCallback &callback)
+    inline DeferredConsumer &onStart(const StartCallback& callback) { return onStart(StartCallback(callback)); }
+    DeferredConsumer &onStart(StartCallback&& callback)
     {
         // store callback
-        _startCallback = callback;
+        _startCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -197,10 +203,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredConsumer &onSize(const SizeCallback &callback)
+    inline DeferredConsumer &onSize(const SizeCallback& callback) { return onSize(SizeCallback(callback)); }
+    DeferredConsumer &onSize(SizeCallback&& callback)
     {
         // store callback
-        _sizeCallback = callback;
+        _sizeCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -212,10 +219,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredConsumer &onHeaders(const HeaderCallback &callback)
+    inline DeferredConsumer &onHeaders(const HeaderCallback& callback) { return onHeaders(HeaderCallback(callback)); }
+    DeferredConsumer &onHeaders(HeaderCallback&& callback)
     {
         // store callback
-        _headerCallback = callback;
+        _headerCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -234,10 +242,11 @@ public:
      *  @param  callback    The callback to invoke for chunks of message data
      *  @return Same object for chaining
      */
-    DeferredConsumer &onData(const DataCallback &callback)
+    inline DeferredConsumer &onData(const DataCallback& callback) { return onData(DataCallback(callback)); }
+    DeferredConsumer &onData(DataCallback&& callback)
     {
         // store callback
-        _dataCallback = callback;
+        _dataCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -249,10 +258,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredConsumer &onComplete(const DeliveredCallback &callback)
+    inline DeferredConsumer &onComplete(const DeliveredCallback& callback) { return onComplete(DeliveredCallback(callback)); }
+    DeferredConsumer &onComplete(DeliveredCallback&& callback)
     {
         // store callback
-        _deliveredCallback = callback;
+        _deliveredCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -264,10 +274,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredConsumer &onDelivered(const DeliveredCallback &callback)
+    inline DeferredConsumer &onDelivered(const DeliveredCallback& callback) { return onDelivered(DeliveredCallback(callback)); }
+    DeferredConsumer &onDelivered(DeliveredCallback&& callback)
     {
         // store callback
-        _deliveredCallback = callback;
+        _deliveredCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferreddelete.h b/include/amqpcpp/deferreddelete.h
index 19b2e09..fa8209c 100644
--- a/include/amqpcpp/deferreddelete.h
+++ b/include/amqpcpp/deferreddelete.h
@@ -76,10 +76,11 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    DeferredDelete &onSuccess(const DeleteCallback &callback)
+    inline DeferredDelete &onSuccess(const DeleteCallback& callback) { return onSuccess(DeleteCallback(callback)); }
+    DeferredDelete &onSuccess(DeleteCallback&& callback)
     {
         // store callback
-        _deleteCallback = callback;
+        _deleteCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -89,10 +90,11 @@ public:
      *  Register the function that is called when the queue is deleted or purged
      *  @param  callback
      */
-    DeferredDelete &onSuccess(const SuccessCallback &callback)
+    inline DeferredDelete &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    DeferredDelete &onSuccess(SuccessCallback&& callback)
     {
         // call base
-        Deferred::onSuccess(callback);
+        Deferred::onSuccess(std::move(callback));
         
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredget.h b/include/amqpcpp/deferredget.h
index f8248a9..e9f6433 100644
--- a/include/amqpcpp/deferredget.h
+++ b/include/amqpcpp/deferredget.h
@@ -95,10 +95,11 @@ public:
      *  This fuction is also available as onReceived() and onMessage() because I always forget which name I gave to it
      *  @param  callback
      */
-    DeferredGet &onSuccess(const MessageCallback &callback)
+    inline DeferredGet &onSuccess(const MessageCallback& callback) { return onSuccess(MessageCallback(callback)); }
+    DeferredGet &onSuccess(MessageCallback&& callback)
     {
         // store the callback
-        _messageCallback = callback;
+        _messageCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -108,10 +109,11 @@ public:
      *  Register a function to be called when an error occurs. This should be defined, otherwise the base methods are used.
      *  @param  callback
      */
-    DeferredGet &onError(const ErrorCallback &callback)
+    inline DeferredGet &onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
+    DeferredGet &onError(ErrorCallback&& callback)
     {
         // store the callback
-        _errorCallback = callback;
+        _errorCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -122,10 +124,11 @@ public:
      *  This fuction is also available as onSuccess() and onMessage() because I always forget which name I gave to it
      *  @param  callback    the callback to execute
      */
-    DeferredGet &onReceived(const MessageCallback &callback)
+    inline DeferredGet &onReceived(const MessageCallback& callback) { return onReceived(MessageCallback(callback)); }
+    DeferredGet &onReceived(MessageCallback&& callback)
     {
         // store callback
-        _messageCallback = callback;
+        _messageCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -136,10 +139,11 @@ public:
      *  This fuction is also available as onSuccess() and onReceived() because I always forget which name I gave to it
      *  @param  callback    the callback to execute
      */
-    DeferredGet &onMessage(const MessageCallback &callback)
+    inline DeferredGet &onMessage(const MessageCallback& callback) { return onMessage(MessageCallback(callback)); }
+    DeferredGet &onMessage(MessageCallback&& callback)
     {
         // store callback
-        _messageCallback = callback;
+        _messageCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -149,10 +153,11 @@ public:
      *  Register a function to be called if no message could be fetched
      *  @param  callback    the callback to execute
      */
-    DeferredGet &onEmpty(const EmptyCallback &callback)
+    inline DeferredGet &onEmpty(const EmptyCallback& callback) { return onEmpty(EmptyCallback(callback)); }
+    DeferredGet &onEmpty(EmptyCallback&& callback)
     {
         // store callback
-        _emptyCallback = callback;
+        _emptyCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -162,10 +167,11 @@ public:
      *  Register a function to be called when queue size information is known
      *  @param  callback    the callback to execute
      */
-    DeferredGet &onCount(const CountCallback &callback)
+    inline DeferredGet &onCount(const CountCallback& callback) { return onCount(CountCallback(callback)); }
+    DeferredGet &onCount(CountCallback&& callback)
     {
         // store callback
-        _countCallback = callback;
+        _countCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -177,10 +183,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredGet &onBegin(const StartCallback &callback)
+    inline DeferredGet &onBegin(const StartCallback& callback) { return onBegin(StartCallback(callback)); }
+    DeferredGet &onBegin(StartCallback&& callback)
     {
         // store callback
-        _startCallback = callback;
+        _startCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -192,10 +199,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredGet &onStart(const StartCallback &callback)
+    inline DeferredGet &onStart(const StartCallback& callback) { return onStart(StartCallback(callback)); }
+    DeferredGet &onStart(StartCallback&& callback)
     {
         // store callback
-        _startCallback = callback;
+        _startCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -207,10 +215,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredGet &onSize(const SizeCallback &callback)
+    inline DeferredGet &onSize(const SizeCallback& callback) { return onSize(SizeCallback(callback)); }
+    DeferredGet &onSize(SizeCallback&& callback)
     {
         // store callback
-        _sizeCallback = callback;
+        _sizeCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -222,10 +231,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredGet &onHeaders(const HeaderCallback &callback)
+    inline DeferredGet &onHeaders(const HeaderCallback& callback) { return onHeaders(HeaderCallback(callback)); }
+    DeferredGet &onHeaders(HeaderCallback&& callback)
     {
         // store callback
-        _headerCallback = callback;
+        _headerCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -244,10 +254,11 @@ public:
      *  @param  callback    The callback to invoke for chunks of message data
      *  @return Same object for chaining
      */
-    DeferredGet &onData(const DataCallback &callback)
+    inline DeferredGet &onData(const DataCallback& callback) { return onData(DataCallback(callback)); }
+    DeferredGet &onData(DataCallback&& callback)
     {
         // store callback
-        _dataCallback = callback;
+        _dataCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -259,10 +270,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredGet &onComplete(const DeliveredCallback &callback)
+    inline DeferredGet &onComplete(const DeliveredCallback& callback) { return onComplete(DeliveredCallback(callback)); }
+    DeferredGet &onComplete(DeliveredCallback&& callback)
     {
         // store callback
-        _deliveredCallback = callback;
+        _deliveredCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -274,10 +286,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredGet &onDelivered(const DeliveredCallback &callback)
+    inline DeferredGet &onDelivered(const DeliveredCallback& callback) { return onDelivered(DeliveredCallback(callback)); }
+    DeferredGet &onDelivered(DeliveredCallback&& callback)
     {
         // store callback
-        _deliveredCallback = callback;
+        _deliveredCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredpublish.h b/include/amqpcpp/deferredpublish.h
index 28a8fea..7698cee 100644
--- a/include/amqpcpp/deferredpublish.h
+++ b/include/amqpcpp/deferredpublish.h
@@ -104,10 +104,11 @@ public:
      *  Callback that is called when the broker confirmed message publication
      *  @param  callback    the callback to execute
      */
-    DeferredPublish &onAck(const PublishAckCallback &callback)
+    inline DeferredPublish &onAck(const PublishAckCallback& callback) { return onAck(PublishAckCallback(callback)); }
+    DeferredPublish &onAck(PublishAckCallback&& callback)
     {
         // store callback
-        _ackCallback = callback;
+        _ackCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -117,10 +118,11 @@ public:
      *  Callback that is called when the broker denied message publication
      *  @param  callback    the callback to execute
      */
-    DeferredPublish &onNack(const PublishNackCallback &callback)
+    inline DeferredPublish &onNack(const PublishNackCallback& callback) { return onNack(PublishNackCallback(callback)); }
+    DeferredPublish &onNack(PublishNackCallback&& callback)
     {
         // store callback
-        _nackCallback = callback;
+        _nackCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -131,10 +133,11 @@ public:
      *  rejecting it or because of a channel error
      *  @param  callback    the callback to execute
      */
-    DeferredPublish &onLost(const PublishLostCallback &callback)
+    inline DeferredPublish &onLost(const PublishLostCallback& callback) { return onLost(PublishLostCallback(callback)); }
+    DeferredPublish &onLost(PublishLostCallback&& callback)
     {
         // store callback
-        _lostCallback = callback;
+        _lostCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredqueue.h b/include/amqpcpp/deferredqueue.h
index 4c84d12..00d0907 100644
--- a/include/amqpcpp/deferredqueue.h
+++ b/include/amqpcpp/deferredqueue.h
@@ -76,10 +76,11 @@ public:
      *
      *  @param  callback    the callback to execute
      */
-    DeferredQueue &onSuccess(const QueueCallback &callback)
+    inline DeferredQueue &onSuccess(const QueueCallback& callback) { return onSuccess(QueueCallback(callback)); }
+    DeferredQueue &onSuccess(QueueCallback&& callback)
     {
         // store callback
-        _queueCallback = callback;
+        _queueCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -89,10 +90,11 @@ public:
      *  Register the function that is called when the queue is declared
      *  @param  callback
      */
-    DeferredQueue &onSuccess(const SuccessCallback &callback)
+    inline DeferredQueue &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
+    DeferredQueue &onSuccess(SuccessCallback&& callback)
     {
         // call base
-        Deferred::onSuccess(callback);
+        Deferred::onSuccess(std::move(callback));
         
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/deferredrecall.h b/include/amqpcpp/deferredrecall.h
index 5451110..8007c1b 100644
--- a/include/amqpcpp/deferredrecall.h
+++ b/include/amqpcpp/deferredrecall.h
@@ -101,10 +101,11 @@ public:
      *  Register a function to be called when a full message is returned
      *  @param  callback    the callback to execute
      */
-    DeferredRecall &onReceived(const BounceCallback &callback)
+    inline DeferredRecall &onReceived(const BounceCallback& callback) { return onReceived(BounceCallback(callback)); }
+    DeferredRecall &onReceived(BounceCallback&& callback)
     {
         // store callback
-        _bounceCallback = callback;
+        _bounceCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -114,10 +115,11 @@ public:
      *  Alias for onReceived() (see above)
      *  @param  callback    the callback to execute
      */
-    DeferredRecall &onMessage(const BounceCallback &callback)
+    inline DeferredRecall &onMessage(const BounceCallback& callback) { return onMessage(BounceCallback(callback)); }
+    DeferredRecall &onMessage(BounceCallback&& callback)
     {
         // store callback
-        _bounceCallback = callback;
+        _bounceCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -127,10 +129,11 @@ public:
      *  Alias for onReceived() (see above)
      *  @param  callback    the callback to execute
      */
-    DeferredRecall &onReturned(const BounceCallback &callback)
+    inline DeferredRecall &onReturned(const BounceCallback& callback) { return onReturned(BounceCallback(callback)); }
+    DeferredRecall &onReturned(BounceCallback&& callback)
     {
         // store callback
-        _bounceCallback = callback;
+        _bounceCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -140,10 +143,11 @@ public:
      *  Alias for onReceived() (see above)
      *  @param  callback    the callback to execute
      */
-    DeferredRecall &onBounced(const BounceCallback &callback)
+    inline DeferredRecall &onBounced(const BounceCallback& callback) { return onBounced(BounceCallback(callback)); }
+    DeferredRecall &onBounced(BounceCallback&& callback)
     {
         // store callback
-        _bounceCallback = callback;
+        _bounceCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -156,10 +160,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredRecall &onBegin(const ReturnCallback &callback)
+    inline DeferredRecall &onBegin(const ReturnCallback& callback) { return onBegin(ReturnCallback(callback)); }
+    DeferredRecall &onBegin(ReturnCallback&& callback)
     {
         // store callback
-        _beginCallback = callback;
+        _beginCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -171,10 +176,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredRecall &onSize(const SizeCallback &callback)
+    inline DeferredRecall &onSize(const SizeCallback& callback) { return onSize(SizeCallback(callback)); }
+    DeferredRecall &onSize(SizeCallback&& callback)
     {
         // store callback
-        _sizeCallback = callback;
+        _sizeCallback = std::move(callback);
         
         // allow chaining
         return *this;
@@ -186,10 +192,11 @@ public:
      *  @param  callback    The callback to invoke for message headers
      *  @return Same object for chaining
      */
-    DeferredRecall &onHeaders(const HeaderCallback &callback)
+    inline DeferredRecall &onHeaders(const HeaderCallback& callback) { return onHeaders(HeaderCallback(callback)); }
+    DeferredRecall &onHeaders(HeaderCallback&& callback)
     {
         // store callback
-        _headerCallback = callback;
+        _headerCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -208,10 +215,11 @@ public:
      *  @param  callback    The callback to invoke for chunks of message data
      *  @return Same object for chaining
      */
-    DeferredRecall &onData(const DataCallback &callback)
+    inline DeferredRecall &onData(const DataCallback& callback) { return onData(DataCallback(callback)); }
+    DeferredRecall &onData(DataCallback&& callback)
     {
         // store callback
-        _dataCallback = callback;
+        _dataCallback = std::move(callback);
 
         // allow chaining
         return *this;
@@ -223,10 +231,11 @@ public:
      *  @param  callback    The callback to invoke
      *  @return Same object for chaining
      */
-    DeferredRecall &onComplete(const ReturnedCallback &callback)
+    inline DeferredRecall &onComplete(const ReturnedCallback& callback) { return onComplete(ReturnedCallback(callback)); }
+    DeferredRecall &onComplete(ReturnedCallback&& callback)
     {
         // store callback
-        _completeCallback = callback;
+        _completeCallback = std::move(callback);
 
         // allow chaining
         return *this;
diff --git a/include/amqpcpp/tagger.h b/include/amqpcpp/tagger.h
index 6ddb733..5d472a1 100644
--- a/include/amqpcpp/tagger.h
+++ b/include/amqpcpp/tagger.h
@@ -136,7 +136,8 @@ public:
      *  Install an error callback
      *  @param  callback
      */
-    void onError(const ErrorCallback &callback);
+    inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
+    void onError(ErrorCallback&& callback);
 };
 
 /**
diff --git a/src/channelimpl.cpp b/src/channelimpl.cpp
index 451ece6..086da31 100644
--- a/src/channelimpl.cpp
+++ b/src/channelimpl.cpp
@@ -65,34 +65,34 @@ ChannelImpl::~ChannelImpl()
  *
  *  @param  callback    the callback to execute
  */
-void ChannelImpl::onError(const ErrorCallback &callback)
+void ChannelImpl::onError(ErrorCallback&& callback)
 {
     // store callback
-    _errorCallback = callback;
+    _errorCallback = std::move(callback);
 
     // if the channel is usable, all is ok
     if (usable()) return;
 
     // validity check
-    if (!callback) return;
+    if (!_errorCallback) return;
 
     // is the channel closing down?
-    if (_state == state_closing) return callback("Channel is closing down");
+    if (_state == state_closing) return _errorCallback("Channel is closing down");
 
     // the channel is closed, but what is the connection doing?
-    if (_connection == nullptr) return callback("Channel is not linked to a connection");
+    if (_connection == nullptr) return _errorCallback("Channel is not linked to a connection");
     
     // if the connection is valid, this is a pure channel error
-    if (_connection->ready()) return callback("Channel is in an error state, but the connection is valid");
+    if (_connection->ready()) return _errorCallback("Channel is in an error state, but the connection is valid");
 
     // the connection is closing down
-    if (_connection->closing()) return callback("Channel is in an error state, the AMQP connection is closing down");
+    if (_connection->closing()) return _errorCallback("Channel is in an error state, the AMQP connection is closing down");
 
     // the connection is already closed
-    if (_connection->closed()) return callback("Channel is in an error state, the AMQP connection has been closed");
+    if (_connection->closed()) return _errorCallback("Channel is in an error state, the AMQP connection has been closed");
    
     // direct call if channel is already in error state
-    callback("Channel is in error state, something went wrong with the AMQP connection");
+    _errorCallback("Channel is in error state, something went wrong with the AMQP connection");
 }
 
 /**
diff --git a/src/tagger.cpp b/src/tagger.cpp
index 2570667..03f38e0 100644
--- a/src/tagger.cpp
+++ b/src/tagger.cpp
@@ -182,19 +182,19 @@ Deferred &Tagger::close()
  *  Install an error callback
  *  @param  callback
  */
-void Tagger::onError(const ErrorCallback &callback)
+void Tagger::onError(ErrorCallback&& callback)
 {
     // we store the callback
-    _errorCallback = callback;
+    _errorCallback = std::move(callback);
 
     // check the callback
-    if (!callback) return;
+    if (!_errorCallback) return;
 
     // if the channel is no longer usable, report that
-    if (!_implementation->usable()) return callback("Channel is no longer usable");
+    if (!_implementation->usable()) return _errorCallback("Channel is no longer usable");
 
     // specify that we're already closing
-    if (_close) callback("Wrapped channel is closing down");
+    if (_close) _errorCallback("Wrapped channel is closing down");
 }
 
 /**