jessequ
/
AMQP-CPP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #455 from pgit/always-move-callbacks 

Always move callbacks
This commit is contained in:
Emiel Bruijntjes 2022-03-28 12:47:33 +02:00 committed by GitHub
parent 5b213a31a9 060e42a6dd
commit 98deb04dac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 175 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -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 // 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 Just like many others methods in the Channel class, the declareQueue() method

12
include/amqpcpp/channel.h
View File

@ -76,10 +76,11 @@ public:
* times will remove the old callback. * times will remove the old callback.
* *
* @param callback the callback to execute * @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 * @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));
} }
/** /**

10
include/amqpcpp/channelimpl.h
View File

@ -212,13 +212,14 @@ public:
* Callback that is called when the channel was succesfully created. * Callback that is called when the channel was succesfully created.
* @param callback the callback to execute * @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 // store callback
_readyCallback = callback; _readyCallback = std::move(callback);
// direct call if channel is already ready // 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 * @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 * Pause deliveries on a channel

17
include/amqpcpp/deferred.h
View File

@ -243,10 +243,11 @@ public:
* *
* @param callback the callback to execute * @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 // store callback
_successCallback = callback; _successCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -262,13 +263,14 @@ public:
* *
* @param callback the callback to execute * @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 // store callback
_errorCallback = callback; _errorCallback = std::move(callback);
// if the object is already in a failed state, we call the callback right away // 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 // allow chaining
return *this; return *this;
@ -289,13 +291,14 @@ public:
* *
* @param callback the callback to execute * @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 the object is already in a failed state, we call the callback right away
if (_failed) callback(); if (_failed) callback();
// otherwise we store callback until it's time for the call // otherwise we store callback until it's time for the call
else _finalizeCallback = callback; else _finalizeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

10
include/amqpcpp/deferredcancel.h
View File

@ -74,10 +74,11 @@ public:
* *
* @param callback the callback to execute * @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 // store callback
_cancelCallback = callback; _cancelCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -87,10 +88,11 @@ public:
* Register the function that is called when the cancel operation succeeded * Register the function that is called when the cancel operation succeeded
* @param callback * @param callback
*/ */
DeferredCancel &onSuccess(const SuccessCallback &callback) inline DeferredCancel &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
DeferredCancel &onSuccess(SuccessCallback&& callback)
{ {
// call base // call base
Deferred::onSuccess(callback); Deferred::onSuccess(std::move(callback));
// allow chaining // allow chaining
return *this; return *this;

15
include/amqpcpp/deferredconfirm.h
View File

@ -76,10 +76,11 @@ public:
* confirmed mode * confirmed mode
* @param callback * @param callback
*/ */
DeferredConfirm &onSuccess(const SuccessCallback &callback) inline DeferredConfirm &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
DeferredConfirm &onSuccess(SuccessCallback&& callback)
{ {
// call base // call base
Deferred::onSuccess(callback); Deferred::onSuccess(std::move(callback));
// allow chaining // allow chaining
return *this; return *this;
@ -89,10 +90,11 @@ public:
* Callback that is called when the broker confirmed message publication * Callback that is called when the broker confirmed message publication
* @param callback the callback to execute * @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 // store callback
_ackCallback = callback; _ackCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -102,10 +104,11 @@ public:
* Callback that is called when the broker denied message publication * Callback that is called when the broker denied message publication
* @param callback the callback to execute * @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 // store callback
_nackCallback = callback; _nackCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

55
include/amqpcpp/deferredconsumer.h
View File

@ -87,10 +87,11 @@ public:
* that you need to later stop the consumer * that you need to later stop the consumer
* @param callback * @param callback
*/ */
DeferredConsumer &onSuccess(const ConsumeCallback &callback) inline DeferredConsumer &onSuccess(const ConsumeCallback& callback) { return onSuccess(ConsumeCallback(callback)); }
DeferredConsumer &onSuccess(ConsumeCallback&& callback)
{ {
// store the callback // store the callback
_consumeCallback = callback; _consumeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -102,10 +103,11 @@ public:
* since that will also pass the consumer-tag as parameter. * since that will also pass the consumer-tag as parameter.
* @param callback * @param callback
*/ */
DeferredConsumer &onSuccess(const SuccessCallback &callback) inline DeferredConsumer &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
DeferredConsumer &onSuccess(SuccessCallback&& callback)
{ {
// call base // call base
Deferred::onSuccess(callback); Deferred::onSuccess(std::move(std::move(callback)));
// allow chaining // allow chaining
return *this; return *this;
@ -115,10 +117,11 @@ public:
* Register a function to be called when a full message is received * Register a function to be called when a full message is received
* @param callback the callback to execute * @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 // store callback
_messageCallback = callback; _messageCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -128,10 +131,11 @@ public:
* Alias for onReceived() (see above) * Alias for onReceived() (see above)
* @param callback the callback to execute * @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 // store callback
_messageCallback = callback; _messageCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -166,10 +170,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_startCallback = callback; _startCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -182,10 +187,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_startCallback = callback; _startCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -197,10 +203,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_sizeCallback = callback; _sizeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -212,10 +219,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_headerCallback = callback; _headerCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -234,10 +242,11 @@ public:
* @param callback The callback to invoke for chunks of message data * @param callback The callback to invoke for chunks of message data
* @return Same object for chaining * @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 // store callback
_dataCallback = callback; _dataCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -249,10 +258,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_deliveredCallback = callback; _deliveredCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -264,10 +274,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_deliveredCallback = callback; _deliveredCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

10
include/amqpcpp/deferreddelete.h
View File

@ -76,10 +76,11 @@ public:
* *
* @param callback the callback to execute * @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 // store callback
_deleteCallback = callback; _deleteCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -89,10 +90,11 @@ public:
* Register the function that is called when the queue is deleted or purged * Register the function that is called when the queue is deleted or purged
* @param callback * @param callback
*/ */
DeferredDelete &onSuccess(const SuccessCallback &callback) inline DeferredDelete &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
DeferredDelete &onSuccess(SuccessCallback&& callback)
{ {
// call base // call base
Deferred::onSuccess(callback); Deferred::onSuccess(std::move(callback));
// allow chaining // allow chaining
return *this; return *this;

65
include/amqpcpp/deferredget.h
View File

@ -95,10 +95,11 @@ public:
* This fuction is also available as onReceived() and onMessage() because I always forget which name I gave to it * This fuction is also available as onReceived() and onMessage() because I always forget which name I gave to it
* @param callback * @param callback
*/ */
DeferredGet &onSuccess(const MessageCallback &callback) inline DeferredGet &onSuccess(const MessageCallback& callback) { return onSuccess(MessageCallback(callback)); }
DeferredGet &onSuccess(MessageCallback&& callback)
{ {
// store the callback // store the callback
_messageCallback = callback; _messageCallback = std::move(callback);
// allow chaining // allow chaining
return *this; 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. * Register a function to be called when an error occurs. This should be defined, otherwise the base methods are used.
* @param callback * @param callback
*/ */
DeferredGet &onError(const ErrorCallback &callback) inline DeferredGet &onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
DeferredGet &onError(ErrorCallback&& callback)
{ {
// store the callback // store the callback
_errorCallback = callback; _errorCallback = std::move(callback);
// allow chaining // allow chaining
return *this; 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 * 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 * @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 // store callback
_messageCallback = callback; _messageCallback = std::move(callback);
// allow chaining // allow chaining
return *this; 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 * 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 * @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 // store callback
_messageCallback = callback; _messageCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -149,10 +153,11 @@ public:
* Register a function to be called if no message could be fetched * Register a function to be called if no message could be fetched
* @param callback the callback to execute * @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 // store callback
_emptyCallback = callback; _emptyCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -162,10 +167,11 @@ public:
* Register a function to be called when queue size information is known * Register a function to be called when queue size information is known
* @param callback the callback to execute * @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 // store callback
_countCallback = callback; _countCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -177,10 +183,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_startCallback = callback; _startCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -192,10 +199,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_startCallback = callback; _startCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -207,10 +215,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_sizeCallback = callback; _sizeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -222,10 +231,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_headerCallback = callback; _headerCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -244,10 +254,11 @@ public:
* @param callback The callback to invoke for chunks of message data * @param callback The callback to invoke for chunks of message data
* @return Same object for chaining * @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 // store callback
_dataCallback = callback; _dataCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -259,10 +270,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_deliveredCallback = callback; _deliveredCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -274,10 +286,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_deliveredCallback = callback; _deliveredCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

15
include/amqpcpp/deferredpublish.h
View File

@ -104,10 +104,11 @@ public:
* Callback that is called when the broker confirmed message publication * Callback that is called when the broker confirmed message publication
* @param callback the callback to execute * @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 // store callback
_ackCallback = callback; _ackCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -117,10 +118,11 @@ public:
* Callback that is called when the broker denied message publication * Callback that is called when the broker denied message publication
* @param callback the callback to execute * @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 // store callback
_nackCallback = callback; _nackCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -131,10 +133,11 @@ public:
* rejecting it or because of a channel error * rejecting it or because of a channel error
* @param callback the callback to execute * @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 // store callback
_lostCallback = callback; _lostCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

10
include/amqpcpp/deferredqueue.h
View File

@ -76,10 +76,11 @@ public:
* *
* @param callback the callback to execute * @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 // store callback
_queueCallback = callback; _queueCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -89,10 +90,11 @@ public:
* Register the function that is called when the queue is declared * Register the function that is called when the queue is declared
* @param callback * @param callback
*/ */
DeferredQueue &onSuccess(const SuccessCallback &callback) inline DeferredQueue &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
DeferredQueue &onSuccess(SuccessCallback&& callback)
{ {
// call base // call base
Deferred::onSuccess(callback); Deferred::onSuccess(std::move(callback));
// allow chaining // allow chaining
return *this; return *this;

45
include/amqpcpp/deferredrecall.h
View File

@ -101,10 +101,11 @@ public:
* Register a function to be called when a full message is returned * Register a function to be called when a full message is returned
* @param callback the callback to execute * @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 // store callback
_bounceCallback = callback; _bounceCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -114,10 +115,11 @@ public:
* Alias for onReceived() (see above) * Alias for onReceived() (see above)
* @param callback the callback to execute * @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 // store callback
_bounceCallback = callback; _bounceCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -127,10 +129,11 @@ public:
* Alias for onReceived() (see above) * Alias for onReceived() (see above)
* @param callback the callback to execute * @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 // store callback
_bounceCallback = callback; _bounceCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -140,10 +143,11 @@ public:
* Alias for onReceived() (see above) * Alias for onReceived() (see above)
* @param callback the callback to execute * @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 // store callback
_bounceCallback = callback; _bounceCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -156,10 +160,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_beginCallback = callback; _beginCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -171,10 +176,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_sizeCallback = callback; _sizeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -186,10 +192,11 @@ public:
* @param callback The callback to invoke for message headers * @param callback The callback to invoke for message headers
* @return Same object for chaining * @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 // store callback
_headerCallback = callback; _headerCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -208,10 +215,11 @@ public:
* @param callback The callback to invoke for chunks of message data * @param callback The callback to invoke for chunks of message data
* @return Same object for chaining * @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 // store callback
_dataCallback = callback; _dataCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;
@ -223,10 +231,11 @@ public:
* @param callback The callback to invoke * @param callback The callback to invoke
* @return Same object for chaining * @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 // store callback
_completeCallback = callback; _completeCallback = std::move(callback);
// allow chaining // allow chaining
return *this; return *this;

3
include/amqpcpp/tagger.h
View File

@ -136,7 +136,8 @@ public:
* Install an error callback * Install an error callback
* @param callback * @param callback
*/ */
void onError(const ErrorCallback &callback); inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
void onError(ErrorCallback&& callback);
}; };
/** /**

18
src/channelimpl.cpp
View File

@ -65,34 +65,34 @@ ChannelImpl::~ChannelImpl()
* *
* @param callback the callback to execute * @param callback the callback to execute
*/ */
void ChannelImpl::onError(const ErrorCallback &callback) void ChannelImpl::onError(ErrorCallback&& callback)
{ {
// store callback // store callback
_errorCallback = callback; _errorCallback = std::move(callback);
// if the channel is usable, all is ok // if the channel is usable, all is ok
if (usable()) return; if (usable()) return;
// validity check // validity check
if (!callback) return; if (!_errorCallback) return;
// is the channel closing down? // 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? // 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 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 // 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 // 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 // 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");
} }
/** /**

10
src/tagger.cpp
View File

@ -182,19 +182,19 @@ Deferred &Tagger::close()
* Install an error callback * Install an error callback
* @param callback * @param callback
*/ */
void Tagger::onError(const ErrorCallback &callback) void Tagger::onError(ErrorCallback&& callback)
{ {
// we store the callback // we store the callback
_errorCallback = callback; _errorCallback = std::move(callback);
// check the callback // check the callback
if (!callback) return; if (!_errorCallback) return;
// if the channel is no longer usable, report that // 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 // specify that we're already closing
if (_close) callback("Wrapped channel is closing down"); if (_close) _errorCallback("Wrapped channel is closing down");
} }
/** /**