Use function pointer syntax for connect statements

Change-Id: I0fe67e7307f67543f0c63a5be46b92f2dd074d45
Reviewed-by: Karsten Heimrich <karsten.heimrich@qt.io>

9 files changed, 51 insertions, 82 deletions

diff --git a/src/coap/qcoapclient.cpp b/src/coap/qcoapclient.cpp
index 834a7d3..7df1295 100644
--- a/src/coap/qcoapclient.cpp
+++ b/src/coap/qcoapclient.cpp
@@ -29,6 +29,7 @@
 ****************************************************************************/
 
 #include "qcoapclient_p.h"
+#include "qcoapprotocol_p.h"
 #include "qcoapreply.h"
 #include "qcoapdiscoveryreply.h"
 #include "qcoapnamespace.h"
@@ -322,10 +323,16 @@ QCoapClient::QCoapClient(QCoapProtocol *protocol, QCoapConnection *connection, Q
     qRegisterMetaType<QCoapMessageId>("QCoapMessageId");
     qRegisterMetaType<QAbstractSocket::SocketOption>();
 
-    connect(d->connection, SIGNAL(readyRead(const QByteArray &, const QHostAddress &)),
-            d->protocol, SLOT(onFrameReceived(const QByteArray &, const QHostAddress &)));
-    connect(d->connection, SIGNAL(error(QAbstractSocket::SocketError)),
-            d->protocol, SLOT(onConnectionError(QAbstractSocket::SocketError)));
+    connect(d->connection, &QCoapConnection::readyRead, d->protocol,
+            [this](const QByteArray &data, const QHostAddress &sender) {
+                    Q_D(QCoapClient);
+                    d->protocol->d_func()->onFrameReceived(data, sender);
+            });
+    connect(d->connection, &QCoapConnection::error, d->protocol,
+            [this](QAbstractSocket::SocketError socketError) {
+                    Q_D(QCoapClient);
+                    d->protocol->d_func()->onConnectionError(socketError);
+            });
 
     connect(d->protocol, &QCoapProtocol::finished,
             this, &QCoapClient::finished);
@@ -647,8 +654,6 @@ QCoapDiscoveryReply *QCoapClientPrivate::sendDiscovery(const QCoapRequest &reque
 */
 bool QCoapClientPrivate::send(QCoapReply *reply)
 {
-    Q_Q(QCoapClient);
-
     const auto scheme = connection->isSecure() ? QLatin1String("coaps") : QLatin1String("coap");
     if (reply->request().url().scheme() != scheme) {
         qWarning("QCoapClient: Failed to send request, URL has an incorrect scheme.");
@@ -660,9 +665,6 @@ bool QCoapClientPrivate::send(QCoapReply *reply)
         return false;
     }
 
-    q->connect(reply, SIGNAL(aborted(const QCoapToken &)),
-               protocol, SLOT(onRequestAborted(const QCoapToken &)));
-
     QMetaObject::invokeMethod(protocol, "sendRequest", Qt::QueuedConnection,
                               Q_ARG(QPointer<QCoapReply>, QPointer<QCoapReply>(reply)),
                               Q_ARG(QCoapConnection *, connection));
diff --git a/src/coap/qcoapinternalrequest.cpp b/src/coap/qcoapinternalrequest.cpp
index f0183f7..0d1d62b 100644
--- a/src/coap/qcoapinternalrequest.cpp
+++ b/src/coap/qcoapinternalrequest.cpp
@@ -60,10 +60,11 @@ QCoapInternalRequest::QCoapInternalRequest(QObject *parent) :
 {
     Q_D(QCoapInternalRequest);
     d->timeoutTimer = new QTimer(this);
-    connect(d->timeoutTimer, SIGNAL(timeout()), this, SLOT(_q_timeout()));
+    connect(d->timeoutTimer, &QTimer::timeout, [this]() { emit timeout(this); });
 
     d->maxTransmitWaitTimer = new QTimer(this);
-    connect(d->maxTransmitWaitTimer, SIGNAL(timeout()), this, SLOT(_q_maxTransmissionSpanReached()));
+    connect(d->maxTransmitWaitTimer, &QTimer::timeout,
+            [this]() { emit maxTransmissionSpanReached(this); });
 }
 
 /*!
@@ -498,29 +499,6 @@ void QCoapInternalRequest::stopTransmission()
 
 /*!
     \internal
-    This slot emits a \l{QCoapInternalRequest::timeout(QCoapInternalRequest*)}
-    {timeout(QCoapInternalRequest*)} signal, which gets forwarded to
-    QCoapProtocolPrivate::onRequestTimeout().
-*/
-void QCoapInternalRequestPrivate::_q_timeout()
-{
-    Q_Q(QCoapInternalRequest);
-    emit q->timeout(q);
-}
-
-/*!
-    \internal
-    This slot emits a \l{QCoapInternalRequest::maxTransmissionSpanReached(QCoapInternalRequest*)}
-    {timeout(QCoapInternalRequest*)} signal.
-*/
-void QCoapInternalRequestPrivate::_q_maxTransmissionSpanReached()
-{
-    Q_Q(QCoapInternalRequest);
-    emit q->maxTransmissionSpanReached(q);
-}
-
-/*!
-    \internal
     Returns the target uri.
 
     \sa setTargetUri()
diff --git a/src/coap/qcoapinternalrequest_p.h b/src/coap/qcoapinternalrequest_p.h
index 21fd1e8..0959f47 100644
--- a/src/coap/qcoapinternalrequest_p.h
+++ b/src/coap/qcoapinternalrequest_p.h
@@ -107,8 +107,6 @@ protected:
 
 private:
     Q_DECLARE_PRIVATE(QCoapInternalRequest)
-    Q_PRIVATE_SLOT(d_func(), void _q_timeout())
-    Q_PRIVATE_SLOT(d_func(), void _q_maxTransmissionSpanReached())
 };
 
 class Q_AUTOTEST_EXPORT QCoapInternalRequestPrivate : public QCoapInternalMessagePrivate
@@ -129,9 +127,6 @@ public:
     bool observeCancelled = false;
     bool transmissionInProgress = false;
 
-    void _q_timeout();
-    void _q_maxTransmissionSpanReached();
-
     Q_DECLARE_PUBLIC(QCoapInternalRequest)
 };
 
diff --git a/src/coap/qcoapprotocol.cpp b/src/coap/qcoapprotocol.cpp
index 8635841..d01e50c 100644
--- a/src/coap/qcoapprotocol.cpp
+++ b/src/coap/qcoapprotocol.cpp
@@ -87,6 +87,11 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
     if (reply.isNull() || !reply->request().isValid())
         return;
 
+    connect(reply, &QCoapReply::aborted, this, [this](const QCoapToken &token) {
+        Q_D(QCoapProtocol);
+        d->onRequestAborted(token);
+    });
+
     auto internalRequest = QSharedPointer<QCoapInternalRequest>::create(reply->request(), this);
     internalRequest->setMaxTransmissionWait(maxTransmitWait());
     connect(reply, &QCoapReply::finished, this, &QCoapProtocol::finished);
@@ -114,11 +119,16 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
     else
         internalRequest->setTimeout(maxTimeout());
 
-    connect(internalRequest.data(), SIGNAL(timeout(QCoapInternalRequest *)),
-            this, SLOT(onRequestTimeout(QCoapInternalRequest *)));
-    connect(internalRequest.data(), SIGNAL(maxTransmissionSpanReached(QCoapInternalRequest *)),
-            this, SLOT(onRequestMaxTransmissionSpanReached(QCoapInternalRequest *)));
-
+    connect(internalRequest.data(), &QCoapInternalRequest::timeout,
+            [this](QCoapInternalRequest *request) {
+                    Q_D(QCoapProtocol);
+                    d->onRequestTimeout(request);
+            });
+    connect(internalRequest.data(), &QCoapInternalRequest::maxTransmissionSpanReached,
+            [this](QCoapInternalRequest *request) {
+                    Q_D(QCoapProtocol);
+                    d->onRequestMaxTransmissionSpanReached(request);
+            });
     d->sendRequest(internalRequest.data());
 }
 
@@ -223,6 +233,7 @@ void QCoapProtocolPrivate::onRequestError(QCoapInternalRequest *request, QtCoap:
     forgetExchange(request);
     emit q->error(userReply.data(), error);
 }
+
 /*!
     \internal
 
diff --git a/src/coap/qcoapprotocol.h b/src/coap/qcoapprotocol.h
index ec2769d..cde41b7 100644
--- a/src/coap/qcoapprotocol.h
+++ b/src/coap/qcoapprotocol.h
@@ -80,12 +80,8 @@ private Q_SLOTS:
 
 private:
     Q_DECLARE_PRIVATE(QCoapProtocol)
-    Q_PRIVATE_SLOT(d_func(), void onRequestTimeout(QCoapInternalRequest*))
-    Q_PRIVATE_SLOT(d_func(), void onRequestMaxTransmissionSpanReached(QCoapInternalRequest*))
-    Q_PRIVATE_SLOT(d_func(), void sendRequest(QCoapInternalRequest*))
-    Q_PRIVATE_SLOT(d_func(), void onFrameReceived(const QByteArray&, const QHostAddress&))
-    Q_PRIVATE_SLOT(d_func(), void onRequestAborted(const QCoapToken&))
-    Q_PRIVATE_SLOT(d_func(), void onConnectionError(QAbstractSocket::SocketError))
+
+    friend class QCoapClient;
 };
 
 QT_END_NAMESPACE
diff --git a/src/coap/qcoapprotocol_p.h b/src/coap/qcoapprotocol_p.h
index 8ff6b5f..cf76f69 100644
--- a/src/coap/qcoapprotocol_p.h
+++ b/src/coap/qcoapprotocol_p.h
@@ -67,7 +67,6 @@ public:
     QCoapToken generateUniqueToken() const;
 
     QByteArray encode(QCoapInternalRequest *request);
-    void onFrameReceived(const QByteArray &data, const QHostAddress &sender);
     QCoapInternalReply *decode(const QByteArray &data, const QHostAddress &sender);
 
     void sendAcknowledgment(QCoapInternalRequest *request);
@@ -75,14 +74,16 @@ public:
     void sendRequest(QCoapInternalRequest *request);
 
     void onLastMessageReceived(QCoapInternalRequest *request);
-    void onConnectionError(QAbstractSocket::SocketError error);
-    void onRequestAborted(const QCoapToken &token);
-    void onRequestTimeout(QCoapInternalRequest *request);
-    void onRequestMaxTransmissionSpanReached(QCoapInternalRequest *request);
     void onRequestError(QCoapInternalRequest *request, QCoapInternalReply *reply);
     void onRequestError(QCoapInternalRequest *request, QtCoap::Error error,
                         QCoapInternalReply *reply = nullptr);
 
+    void onRequestTimeout(QCoapInternalRequest *request);
+    void onRequestMaxTransmissionSpanReached(QCoapInternalRequest *request);
+    void onFrameReceived(const QByteArray &data, const QHostAddress &sender);
+    void onConnectionError(QAbstractSocket::SocketError error);
+    void onRequestAborted(const QCoapToken &token);
+
     bool isMessageIdRegistered(quint16 id) const;
     bool isTokenRegistered(const QCoapToken &token) const;
     bool isRequestRegistered(const QCoapInternalRequest *request) const;
diff --git a/src/coap/qcoapqudpconnection.cpp b/src/coap/qcoapqudpconnection.cpp
index e3a0fac..a647fbd 100644
--- a/src/coap/qcoapqudpconnection.cpp
+++ b/src/coap/qcoapqudpconnection.cpp
@@ -136,17 +136,23 @@ void QCoapQUdpConnection::createSocket()
 
     d->udpSocket = new QUdpSocket(this);
 
-    connect(d->udpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
-            this, SLOT(_q_socketError(QAbstractSocket::SocketError)));
-    connect(d->udpSocket, SIGNAL(readyRead()), this, SLOT(_q_socketReadyRead()));
+    connect(d->udpSocket, &QUdpSocket::readyRead, [this]() {
+        Q_D(QCoapQUdpConnection);
+        d->socketReadyRead();
+    });
+    connect(d->udpSocket, QOverload<QAbstractSocket::SocketError>::of(&QUdpSocket::error),
+            [this](QAbstractSocket::SocketError socketError) {
+                    qWarning() << "CoAP UDP socket error" << socketError << socket()->errorString();
+                    emit error(socketError);
+            });
 }
 
 QCoapQUdpConnectionPrivate::QCoapQUdpConnectionPrivate(QtCoap::SecurityMode security)
     : QCoapConnectionPrivate(security)
-    , udpSocket(nullptr)
 #if QT_CONFIG(dtls)
     , dtls(nullptr)
 #endif
+    , udpSocket(nullptr)
 {
 }
 
@@ -266,7 +272,7 @@ void QCoapQUdpConnectionPrivate::writeToSocket(const QByteArray &data, const QSt
     This slot reads all data stored in the socket and emits a readyRead()
     signal for each received datagram.
 */
-void QCoapQUdpConnectionPrivate::_q_socketReadyRead()
+void QCoapQUdpConnectionPrivate::socketReadyRead()
 {
     Q_Q(QCoapQUdpConnection);
 
@@ -291,20 +297,6 @@ void QCoapQUdpConnectionPrivate::_q_socketReadyRead()
 }
 
 /*!
-    \internal
-
-    This slot emits the \l{QCoapQUdpConnection::error(QAbstractSocket::SocketError)}
-    {error(QAbstractSocket::SocketError)} signal.
-*/
-void QCoapQUdpConnectionPrivate::_q_socketError(QAbstractSocket::SocketError error)
-{
-    Q_Q(QCoapQUdpConnection);
-
-    qWarning() << "CoAP UDP socket error" << error << socket()->errorString();
-    emit q->error(error);
-}
-
-/*!
     Returns the socket.
 */
 QUdpSocket *QCoapQUdpConnection::socket() const
diff --git a/src/coap/qcoapqudpconnection.h b/src/coap/qcoapqudpconnection.h
index 9e86942..b070d1d 100644
--- a/src/coap/qcoapqudpconnection.h
+++ b/src/coap/qcoapqudpconnection.h
@@ -73,8 +73,6 @@ protected:
     void createSocket();
 
     Q_DECLARE_PRIVATE(QCoapQUdpConnection)
-    Q_PRIVATE_SLOT(d_func(), void _q_socketReadyRead())
-    Q_PRIVATE_SLOT(d_func(), void _q_socketError(QAbstractSocket::SocketError))
 };
 
 QT_END_NAMESPACE
diff --git a/src/coap/qcoapqudpconnection_p.h b/src/coap/qcoapqudpconnection_p.h
index 49d2e84..5491b60 100644
--- a/src/coap/qcoapqudpconnection_p.h
+++ b/src/coap/qcoapqudpconnection_p.h
@@ -63,21 +63,17 @@ public:
     void bindSocket();
     void writeToSocket(const QByteArray &data, const QString &host, quint16 port);
     QUdpSocket* socket() const { return udpSocket; }
+    void socketReadyRead();
 
     void setSecurityConfiguration(const QCoapSecurityConfiguration &configuration);
 
 #if QT_CONFIG(dtls)
     QNetworkDatagram receiveDatagramDecrypted() const;
     void handleEncryptedDatagram();
-#endif
-
-    void _q_socketReadyRead();
-    void _q_socketError(QAbstractSocket::SocketError);
 
-    QPointer<QUdpSocket> udpSocket;
-#if QT_CONFIG(dtls)
     QPointer<QDtls> dtls;
 #endif
+    QPointer<QUdpSocket> udpSocket;
 
     Q_DECLARE_PUBLIC(QCoapQUdpConnection)
 };