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

Added const-ref wrappers to make changes backward-compatible.

This commit is contained in:
Peter Eisenlohr 2022-03-18 23:53:44 +01:00
parent 9c4cfffab8
commit fa1181aa63
14 changed files with 109 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/amqpcpp/channel.h
View File

@ -76,8 +76,9 @@ public:
* times will remove the old callback.
*
* @param callback the callback to execute
*/
void onReady(SuccessCallback&&callback)
*/
inline void onReady(const SuccessCallback& callback) { return onReady(SuccessCallback(callback)); }
void onReady(SuccessCallback&& callback)
{
_implementation->onReady(std::move(callback));
}
@ -90,7 +91,8 @@ public:
*
* @param callback the callback to execute
*/
void onError(ErrorCallback&&callback)
inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
void onError(ErrorCallback&& callback)
{
_implementation->onError(std::move(callback));
}

6
include/amqpcpp/channelimpl.h
View File

@ -212,7 +212,8 @@ public:
* Callback that is called when the channel was succesfully created.
* @param callback the callback to execute
*/
void onReady(SuccessCallback&&callback)
inline void onReady(const SuccessCallback& callback) { return onReady(SuccessCallback(callback)); }
void onReady(SuccessCallback&& callback)
{
// store callback
_readyCallback = std::move(callback);
@ -229,7 +230,8 @@ public:
*
* @param callback the callback to execute
*/
void onError(ErrorCallback&&callback);
inline void onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
void onError(ErrorCallback&& callback);
/**
* Pause deliveries on a channel

9
include/amqpcpp/deferred.h
View File

@ -243,7 +243,8 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onSuccess(SuccessCallback&&callback)
inline Deferred &onSuccess(const SuccessCallback& callback) { return onSuccess(SuccessCallback(callback)); }
Deferred &onSuccess(SuccessCallback&& callback)
{
// store callback
_successCallback = std::move(callback);
@ -262,7 +263,8 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onError(ErrorCallback&&callback)
inline Deferred &onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
Deferred &onError(ErrorCallback&& callback)
{
// store callback
_errorCallback = std::move(callback);
@ -289,7 +291,8 @@ public:
*
* @param callback the callback to execute
*/
Deferred &onFinalize(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();

6
include/amqpcpp/deferredcancel.h
View File

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

9
include/amqpcpp/deferredconfirm.h
View File

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

33
include/amqpcpp/deferredconsumer.h
View File

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

6
include/amqpcpp/deferreddelete.h
View File

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

39
include/amqpcpp/deferredget.h
View File

@ -95,7 +95,8 @@ public:
* This fuction is also available as onReceived() and onMessage() because I always forget which name I gave to it
* @param callback
*/
DeferredGet &onSuccess(MessageCallback&&callback)
inline DeferredGet &onSuccess(const MessageCallback& callback) { return onSuccess(MessageCallback(callback)); }
DeferredGet &onSuccess(MessageCallback&& callback)
{
// store the callback
_messageCallback = std::move(callback);
@ -108,7 +109,8 @@ 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(ErrorCallback&&callback)
inline DeferredGet &onError(const ErrorCallback& callback) { return onError(ErrorCallback(callback)); }
DeferredGet &onError(ErrorCallback&& callback)
{
// store the callback
_errorCallback = std::move(callback);
@ -122,7 +124,8 @@ 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(MessageCallback&&callback)
inline DeferredGet &onReceived(const MessageCallback& callback) { return onReceived(MessageCallback(callback)); }
DeferredGet &onReceived(MessageCallback&& callback)
{
// store callback
_messageCallback = std::move(callback);
@ -136,7 +139,8 @@ 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(MessageCallback&&callback)
inline DeferredGet &onMessage(const MessageCallback& callback) { return onMessage(MessageCallback(callback)); }
DeferredGet &onMessage(MessageCallback&& callback)
{
// store callback
_messageCallback = std::move(callback);
@ -149,7 +153,8 @@ public:
* Register a function to be called if no message could be fetched
* @param callback the callback to execute
*/
DeferredGet &onEmpty(EmptyCallback&&callback)
inline DeferredGet &onEmpty(const EmptyCallback& callback) { return onEmpty(EmptyCallback(callback)); }
DeferredGet &onEmpty(EmptyCallback&& callback)
{
// store callback
_emptyCallback = std::move(callback);
@ -162,7 +167,8 @@ public:
* Register a function to be called when queue size information is known
* @param callback the callback to execute
*/
DeferredGet &onCount(CountCallback&&callback)
inline DeferredGet &onCount(const CountCallback& callback) { return onCount(CountCallback(callback)); }
DeferredGet &onCount(CountCallback&& callback)
{
// store callback
_countCallback = std::move(callback);
@ -177,7 +183,8 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onBegin(StartCallback&&callback)
inline DeferredGet &onBegin(const StartCallback& callback) { return onBegin(StartCallback(callback)); }
DeferredGet &onBegin(StartCallback&& callback)
{
// store callback
_startCallback = std::move(callback);
@ -192,7 +199,8 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onStart(StartCallback&&callback)
inline DeferredGet &onStart(const StartCallback& callback) { return onStart(StartCallback(callback)); }
DeferredGet &onStart(StartCallback&& callback)
{
// store callback
_startCallback = std::move(callback);
@ -207,7 +215,8 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredGet &onSize(SizeCallback&&callback)
inline DeferredGet &onSize(const SizeCallback& callback) { return onSize(SizeCallback(callback)); }
DeferredGet &onSize(SizeCallback&& callback)
{
// store callback
_sizeCallback = std::move(callback);
@ -222,7 +231,8 @@ public:
* @param callback The callback to invoke for message headers
* @return Same object for chaining
*/
DeferredGet &onHeaders(HeaderCallback&&callback)
inline DeferredGet &onHeaders(const HeaderCallback& callback) { return onHeaders(HeaderCallback(callback)); }
DeferredGet &onHeaders(HeaderCallback&& callback)
{
// store callback
_headerCallback = std::move(callback);
@ -244,7 +254,8 @@ public:
* @param callback The callback to invoke for chunks of message data
* @return Same object for chaining
*/
DeferredGet &onData(DataCallback&&callback)
inline DeferredGet &onData(const DataCallback& callback) { return onData(DataCallback(callback)); }
DeferredGet &onData(DataCallback&& callback)
{
// store callback
_dataCallback = std::move(callback);
@ -259,7 +270,8 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onComplete(DeliveredCallback&&callback)
inline DeferredGet &onComplete(const DeliveredCallback& callback) { return onComplete(DeliveredCallback(callback)); }
DeferredGet &onComplete(DeliveredCallback&& callback)
{
// store callback
_deliveredCallback = std::move(callback);
@ -274,7 +286,8 @@ public:
* @param callback The callback to invoke
* @return Same object for chaining
*/
DeferredGet &onDelivered(DeliveredCallback&&callback)
inline DeferredGet &onDelivered(const DeliveredCallback& callback) { return onDelivered(DeliveredCallback(callback)); }
DeferredGet &onDelivered(DeliveredCallback&& callback)
{
// store callback
_deliveredCallback = std::move(callback);

9
include/amqpcpp/deferredpublish.h
View File

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

6
include/amqpcpp/deferredqueue.h
View File

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

27
include/amqpcpp/deferredrecall.h
View File

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

3
include/amqpcpp/tagger.h
View File

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

2
src/channelimpl.cpp
View File

@ -65,7 +65,7 @@ ChannelImpl::~ChannelImpl()
*
* @param callback the callback to execute
*/
void ChannelImpl::onError(ErrorCallback&&callback)
void ChannelImpl::onError(ErrorCallback&& callback)
{
// store callback
_errorCallback = std::move(callback);

2
src/tagger.cpp
View File

@ -182,7 +182,7 @@ Deferred &Tagger::close()
* Install an error callback
* @param callback
*/
void Tagger::onError(ErrorCallback&&callback)
void Tagger::onError(ErrorCallback&& callback)
{
// we store the callback
_errorCallback = std::move(callback);