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

std::move callbacks

This commit is contained in:
Peter Eisenlohr 2022-03-15 14:10:45 +01:00
parent 5b213a31a9
commit 9c4cfffab8
15 changed files with 109 additions and 109 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
channel.declareQueue("myQueue").onSuccess(callback);
channel.declareQueue("myQueue").onSuccess(std::move(callback));
````
Just like many others methods in the Channel class, the declareQueue() method

8
include/amqpcpp/channel.h
View File

@ -77,9 +77,9 @@ public:
*
* @param callback the callback to execute
*/
void onReady(const SuccessCallback &callback)
void onReady(SuccessCallback&&callback)
{
_implementation->onReady(callback);
_implementation->onReady(std::move(callback));
}
/**
@ -90,9 +90,9 @@ public:
*
* @param callback the callback to execute
*/
void onError(const ErrorCallback &callback)
void onError(ErrorCallback&&callback)
{
_implementation->onError(callback);
_implementation->onError(std::move(callback));
}
/**

6
include/amqpcpp/channelimpl.h
View File

@ -212,10 +212,10 @@ public:
* Callback that is called when the channel was succesfully created.
* @param callback the callback to execute
*/
void onReady(const 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();
@ -229,7 +229,7 @@ public:
*
* @param callback the callback to execute
*/
void onError(const ErrorCallback &callback);
void onError(ErrorCallback&&callback);
/**
* Pause deliveries on a channel

12
include/amqpcpp/deferred.h
View File

@ -243,10 +243,10 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onSuccess(const SuccessCallback &callback)
Deferred &onSuccess(SuccessCallback&&callback)
{
// store callback
_successCallback = callback;
_successCallback = std::move(callback);
// allow chaining
return *this;
@ -262,10 +262,10 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onError(const 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");
@ -289,13 +289,13 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onFinalize(const 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;

8
include/amqpcpp/deferredcancel.h
View File

@ -74,10 +74,10 @@ public:
*
* @param callback the callback to execute
*/
DeferredCancel &onSuccess(const CancelCallback &callback)
DeferredCancel &onSuccess(CancelCallback&&callback)
{
// store callback
_cancelCallback = callback;
_cancelCallback = std::move(callback);
// allow chaining
return *this;
@ -87,10 +87,10 @@ public:
* Register the function that is called when the cancel operation succeeded
* @param callback
*/
DeferredCancel &onSuccess(const SuccessCallback &callback)
DeferredCancel &onSuccess(SuccessCallback&&callback)
{
// call base
Deferred::onSuccess(callback);
Deferred::onSuccess(std::move(callback));
// allow chaining
return *this;

12
include/amqpcpp/deferredconfirm.h
View File

@ -76,10 +76,10 @@ public:
* confirmed mode
* @param callback
*/
DeferredConfirm &onSuccess(const SuccessCallback &callback)
DeferredConfirm &onSuccess(SuccessCallback&&callback)
{
// call base
Deferred::onSuccess(callback);
Deferred::onSuccess(std::move(callback));
// allow chaining
return *this;
@ -89,10 +89,10 @@ public:
* Callback that is called when the broker confirmed message publication
* @param callback the callback to execute
*/
DeferredConfirm &onAck(const AckCallback &callback)
DeferredConfirm &onAck(AckCallback&&callback)
{
// store callback
_ackCallback = callback;
_ackCallback = std::move(callback);
// allow chaining
return *this;
@ -102,10 +102,10 @@ public:
* Callback that is called when the broker denied message publication
* @param callback the callback to execute
*/
DeferredConfirm &onNack(const NackCallback &callback)
DeferredConfirm &onNack(NackCallback&&callback)
{
// store callback
_nackCallback = callback;
_nackCallback = std::move(callback);
// allow chaining
return *this;

44
include/amqpcpp/deferredconsumer.h
View File

@ -87,10 +87,10 @@ public:
* that you need to later stop the consumer
* @param callback
*/
DeferredConsumer &onSuccess(const ConsumeCallback &callback)
DeferredConsumer &onSuccess(ConsumeCallback&&callback)
{
// store the callback
_consumeCallback = callback;
_consumeCallback = std::move(callback);
// allow chaining
return *this;
@ -102,10 +102,10 @@ public:
* since that will also pass the consumer-tag as parameter.
* @param callback
*/
DeferredConsumer &onSuccess(const SuccessCallback &callback)
DeferredConsumer &onSuccess(SuccessCallback&&callback)
{
// call base
Deferred::onSuccess(callback);
Deferred::onSuccess(std::move(std::move(callback)));
// allow chaining
return *this;
@ -115,10 +115,10 @@ public:
* Register a function to be called when a full message is received
* @param callback the callback to execute
*/
DeferredConsumer &onReceived(const MessageCallback &callback)
DeferredConsumer &onReceived(MessageCallback&&callback)
{
// store callback
_messageCallback = callback;
_messageCallback = std::move(callback);
// allow chaining
return *this;
@ -128,10 +128,10 @@ public:
* Alias for onReceived() (see above)
* @param callback the callback to execute
*/
DeferredConsumer &onMessage(const MessageCallback &callback)
DeferredConsumer &onMessage(MessageCallback&&callback)
{
// store callback
_messageCallback = callback;
_messageCallback = std::move(callback);
// allow chaining
return *this;
@ -166,10 +166,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredConsumer &onBegin(const StartCallback &callback)
DeferredConsumer &onBegin(StartCallback&&callback)
{
// store callback
_startCallback = callback;
_startCallback = std::move(callback);
// allow chaining
return *this;
@ -182,10 +182,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredConsumer &onStart(const StartCallback &callback)
DeferredConsumer &onStart(StartCallback&&callback)
{
// store callback
_startCallback = callback;
_startCallback = std::move(callback);
// allow chaining
return *this;
@ -197,10 +197,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredConsumer &onSize(const SizeCallback &callback)
DeferredConsumer &onSize(SizeCallback&&callback)
{
// store callback
_sizeCallback = callback;
_sizeCallback = std::move(callback);
// allow chaining
return *this;
@ -212,10 +212,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredConsumer &onHeaders(const HeaderCallback &callback)
DeferredConsumer &onHeaders(HeaderCallback&&callback)
{
// store callback
_headerCallback = callback;
_headerCallback = std::move(callback);
// allow chaining
return *this;
@ -234,10 +234,10 @@ public:
* @param callback The callback to invoke for chunks of message data
* @return Same object for chaining
*/
DeferredConsumer &onData(const DataCallback &callback)
DeferredConsumer &onData(DataCallback&&callback)
{
// store callback
_dataCallback = callback;
_dataCallback = std::move(callback);
// allow chaining
return *this;
@ -249,10 +249,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredConsumer &onComplete(const DeliveredCallback &callback)
DeferredConsumer &onComplete(DeliveredCallback&&callback)
{
// store callback
_deliveredCallback = callback;
_deliveredCallback = std::move(callback);
// allow chaining
return *this;
@ -264,10 +264,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredConsumer &onDelivered(const DeliveredCallback &callback)
DeferredConsumer &onDelivered(DeliveredCallback&&callback)
{
// store callback
_deliveredCallback = callback;
_deliveredCallback = std::move(callback);
// allow chaining
return *this;

8
include/amqpcpp/deferreddelete.h
View File

@ -76,10 +76,10 @@ public:
*
* @param callback the callback to execute
*/
DeferredDelete &onSuccess(const DeleteCallback &callback)
DeferredDelete &onSuccess(DeleteCallback&&callback)
{
// store callback
_deleteCallback = callback;
_deleteCallback = std::move(callback);
// allow chaining
return *this;
@ -89,10 +89,10 @@ public:
* Register the function that is called when the queue is deleted or purged
* @param callback
*/
DeferredDelete &onSuccess(const SuccessCallback &callback)
DeferredDelete &onSuccess(SuccessCallback&&callback)
{
// call base
Deferred::onSuccess(callback);
Deferred::onSuccess(std::move(callback));
// allow chaining
return *this;

52
include/amqpcpp/deferredget.h
View File

@ -95,10 +95,10 @@ 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)
DeferredGet &onSuccess(MessageCallback&&callback)
{
// store the callback
_messageCallback = callback;
_messageCallback = std::move(callback);
// allow chaining
return *this;
@ -108,10 +108,10 @@ 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)
DeferredGet &onError(ErrorCallback&&callback)
{
// store the callback
_errorCallback = callback;
_errorCallback = std::move(callback);
// allow chaining
return *this;
@ -122,10 +122,10 @@ 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)
DeferredGet &onReceived(MessageCallback&&callback)
{
// store callback
_messageCallback = callback;
_messageCallback = std::move(callback);
// allow chaining
return *this;
@ -136,10 +136,10 @@ 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)
DeferredGet &onMessage(MessageCallback&&callback)
{
// store callback
_messageCallback = callback;
_messageCallback = std::move(callback);
// allow chaining
return *this;
@ -149,10 +149,10 @@ public:
* Register a function to be called if no message could be fetched
* @param callback the callback to execute
*/
DeferredGet &onEmpty(const EmptyCallback &callback)
DeferredGet &onEmpty(EmptyCallback&&callback)
{
// store callback
_emptyCallback = callback;
_emptyCallback = std::move(callback);
// allow chaining
return *this;
@ -162,10 +162,10 @@ public:
* Register a function to be called when queue size information is known
* @param callback the callback to execute
*/
DeferredGet &onCount(const CountCallback &callback)
DeferredGet &onCount(CountCallback&&callback)
{
// store callback
_countCallback = callback;
_countCallback = std::move(callback);
// allow chaining
return *this;
@ -177,10 +177,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onBegin(const StartCallback &callback)
DeferredGet &onBegin(StartCallback&&callback)
{
// store callback
_startCallback = callback;
_startCallback = std::move(callback);
// allow chaining
return *this;
@ -192,10 +192,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onStart(const StartCallback &callback)
DeferredGet &onStart(StartCallback&&callback)
{
// store callback
_startCallback = callback;
_startCallback = std::move(callback);
// allow chaining
return *this;
@ -207,10 +207,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredGet &onSize(const SizeCallback &callback)
DeferredGet &onSize(SizeCallback&&callback)
{
// store callback
_sizeCallback = callback;
_sizeCallback = std::move(callback);
// allow chaining
return *this;
@ -222,10 +222,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredGet &onHeaders(const HeaderCallback &callback)
DeferredGet &onHeaders(HeaderCallback&&callback)
{
// store callback
_headerCallback = callback;
_headerCallback = std::move(callback);
// allow chaining
return *this;
@ -244,10 +244,10 @@ public:
* @param callback The callback to invoke for chunks of message data
* @return Same object for chaining
*/
DeferredGet &onData(const DataCallback &callback)
DeferredGet &onData(DataCallback&&callback)
{
// store callback
_dataCallback = callback;
_dataCallback = std::move(callback);
// allow chaining
return *this;
@ -259,10 +259,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onComplete(const DeliveredCallback &callback)
DeferredGet &onComplete(DeliveredCallback&&callback)
{
// store callback
_deliveredCallback = callback;
_deliveredCallback = std::move(callback);
// allow chaining
return *this;
@ -274,10 +274,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onDelivered(const DeliveredCallback &callback)
DeferredGet &onDelivered(DeliveredCallback&&callback)
{
// store callback
_deliveredCallback = callback;
_deliveredCallback = std::move(callback);
// allow chaining
return *this;

12
include/amqpcpp/deferredpublish.h
View File

@ -104,10 +104,10 @@ public:
* Callback that is called when the broker confirmed message publication
* @param callback the callback to execute
*/
DeferredPublish &onAck(const PublishAckCallback &callback)
DeferredPublish &onAck(PublishAckCallback&&callback)
{
// store callback
_ackCallback = callback;
_ackCallback = std::move(callback);
// allow chaining
return *this;
@ -117,10 +117,10 @@ public:
* Callback that is called when the broker denied message publication
* @param callback the callback to execute
*/
DeferredPublish &onNack(const PublishNackCallback &callback)
DeferredPublish &onNack(PublishNackCallback&&callback)
{
// store callback
_nackCallback = callback;
_nackCallback = std::move(callback);
// allow chaining
return *this;
@ -131,10 +131,10 @@ public:
* rejecting it or because of a channel error
* @param callback the callback to execute
*/
DeferredPublish &onLost(const PublishLostCallback &callback)
DeferredPublish &onLost(PublishLostCallback&&callback)
{
// store callback
_lostCallback = callback;
_lostCallback = std::move(callback);
// allow chaining
return *this;

8
include/amqpcpp/deferredqueue.h
View File

@ -76,10 +76,10 @@ public:
*
* @param callback the callback to execute
*/
DeferredQueue &onSuccess(const QueueCallback &callback)
DeferredQueue &onSuccess(QueueCallback&&callback)
{
// store callback
_queueCallback = callback;
_queueCallback = std::move(callback);
// allow chaining
return *this;
@ -89,10 +89,10 @@ public:
* Register the function that is called when the queue is declared
* @param callback
*/
DeferredQueue &onSuccess(const SuccessCallback &callback)
DeferredQueue &onSuccess(SuccessCallback&&callback)
{
// call base
Deferred::onSuccess(callback);
Deferred::onSuccess(std::move(callback));
// allow chaining
return *this;

36
include/amqpcpp/deferredrecall.h
View File

@ -101,10 +101,10 @@ public:
* Register a function to be called when a full message is returned
* @param callback the callback to execute
*/
DeferredRecall &onReceived(const BounceCallback &callback)
DeferredRecall &onReceived(BounceCallback&&callback)
{
// store callback
_bounceCallback = callback;
_bounceCallback = std::move(callback);
// allow chaining
return *this;
@ -114,10 +114,10 @@ public:
* Alias for onReceived() (see above)
* @param callback the callback to execute
*/
DeferredRecall &onMessage(const BounceCallback &callback)
DeferredRecall &onMessage(BounceCallback&&callback)
{
// store callback
_bounceCallback = callback;
_bounceCallback = std::move(callback);
// allow chaining
return *this;
@ -127,10 +127,10 @@ public:
* Alias for onReceived() (see above)
* @param callback the callback to execute
*/
DeferredRecall &onReturned(const BounceCallback &callback)
DeferredRecall &onReturned(BounceCallback&&callback)
{
// store callback
_bounceCallback = callback;
_bounceCallback = std::move(callback);
// allow chaining
return *this;
@ -140,10 +140,10 @@ public:
* Alias for onReceived() (see above)
* @param callback the callback to execute
*/
DeferredRecall &onBounced(const BounceCallback &callback)
DeferredRecall &onBounced(BounceCallback&&callback)
{
// store callback
_bounceCallback = callback;
_bounceCallback = std::move(callback);
// allow chaining
return *this;
@ -156,10 +156,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredRecall &onBegin(const ReturnCallback &callback)
DeferredRecall &onBegin(ReturnCallback&&callback)
{
// store callback
_beginCallback = callback;
_beginCallback = std::move(callback);
// allow chaining
return *this;
@ -171,10 +171,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredRecall &onSize(const SizeCallback &callback)
DeferredRecall &onSize(SizeCallback&&callback)
{
// store callback
_sizeCallback = callback;
_sizeCallback = std::move(callback);
// allow chaining
return *this;
@ -186,10 +186,10 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredRecall &onHeaders(const HeaderCallback &callback)
DeferredRecall &onHeaders(HeaderCallback&&callback)
{
// store callback
_headerCallback = callback;
_headerCallback = std::move(callback);
// allow chaining
return *this;
@ -208,10 +208,10 @@ public:
* @param callback The callback to invoke for chunks of message data
* @return Same object for chaining
*/
DeferredRecall &onData(const DataCallback &callback)
DeferredRecall &onData(DataCallback&&callback)
{
// store callback
_dataCallback = callback;
_dataCallback = std::move(callback);
// allow chaining
return *this;
@ -223,10 +223,10 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredRecall &onComplete(const ReturnedCallback &callback)
DeferredRecall &onComplete(ReturnedCallback&&callback)
{
// store callback
_completeCallback = callback;
_completeCallback = std::move(callback);
// allow chaining
return *this;

2
include/amqpcpp/tagger.h
View File

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

4
src/channelimpl.cpp
View File

@ -65,10 +65,10 @@ 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;

4
src/tagger.cpp
View File

@ -182,10 +182,10 @@ 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;