Code cleanup: replace int by uint, where it makes sense

This saves us several checks and "static_cast"s.

Change-Id: I81e2253929f1fe0a7a052e8c2988e28229b0c9db
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

5 files changed, 46 insertions, 62 deletions

diff --git a/src/coap/qcoapinternalrequest.cpp b/src/coap/qcoapinternalrequest.cpp
index 6f0735e..ec37969 100644
--- a/src/coap/qcoapinternalrequest.cpp
+++ b/src/coap/qcoapinternalrequest.cpp
@@ -250,7 +250,7 @@ QByteArray QCoapInternalRequest::toQByteArray() const
 
     \sa blockOption(), setToSendBlock()
 */
-void QCoapInternalRequest::setToRequestBlock(int blockNumber, int blockSize)
+void QCoapInternalRequest::setToRequestBlock(uint blockNumber, uint blockSize)
 {
     Q_D(QCoapInternalRequest);
 
@@ -260,8 +260,7 @@ void QCoapInternalRequest::setToRequestBlock(int blockNumber, int blockSize)
     d->message.removeOption(QCoapOption::Block1);
     d->message.removeOption(QCoapOption::Block2);
 
-    addOption(blockOption(QCoapOption::Block2, static_cast<uint>(blockNumber),
-                          static_cast<uint>(blockSize)));
+    addOption(blockOption(QCoapOption::Block2, blockNumber, blockSize));
 }
 
 /*!
@@ -271,18 +270,18 @@ void QCoapInternalRequest::setToRequestBlock(int blockNumber, int blockSize)
 
     \sa blockOption(), setToRequestBlock()
 */
-void QCoapInternalRequest::setToSendBlock(int blockNumber, int blockSize)
+void QCoapInternalRequest::setToSendBlock(uint blockNumber, uint blockSize)
 {
     Q_D(QCoapInternalRequest);
 
     if (!checkBlockNumber(blockNumber))
         return;
 
-    d->message.setPayload(d->fullPayload.mid(blockNumber * blockSize, blockSize));
+    d->message.setPayload(d->fullPayload.mid(static_cast<int>(blockNumber * blockSize),
+                                             static_cast<int>(blockSize)));
     d->message.removeOption(QCoapOption::Block1);
 
-    addOption(blockOption(QCoapOption::Block1, static_cast<uint>(blockNumber),
-                          static_cast<uint>(blockSize)));
+    addOption(blockOption(QCoapOption::Block1, blockNumber, blockSize));
 }
 
 /*!
@@ -290,13 +289,8 @@ void QCoapInternalRequest::setToSendBlock(int blockNumber, int blockSize)
     Returns \c true if the block number is valid, \c false otherwise.
     If the block number is not valid, logs a warning message.
 */
-bool QCoapInternalRequest::checkBlockNumber(int blockNumber)
+bool QCoapInternalRequest::checkBlockNumber(uint blockNumber)
 {
-    if (blockNumber < 0) {
-        qWarning() << "QtCoap: Invalid block number" << blockNumber;
-        return false;
-    }
-
     if (blockNumber >> 20) {
         qWarning() << "QtCoap: Block number" << blockNumber << "is too large."
                       " It should fit in 20 bits.";
@@ -484,7 +478,7 @@ void QCoapInternalRequest::restartTransmission()
     }
 
     if (d->timeout > 0)
-        d->timeoutTimer->start(d->timeout);
+        d->timeoutTimer->start(static_cast<int>(d->timeout));
 }
 
 /*!
@@ -592,7 +586,7 @@ bool QCoapInternalRequest::isMulticast() const
     \internal
     Returns the value of the retransmission counter.
 */
-int QCoapInternalRequest::retransmissionCounter() const
+uint QCoapInternalRequest::retransmissionCounter() const
 {
     Q_D(const QCoapInternalRequest);
     return d->retransmissionCounter;
@@ -656,7 +650,7 @@ void QCoapInternalRequest::setTargetUri(QUrl targetUri)
 void QCoapInternalRequest::setTimeout(uint timeout)
 {
     Q_D(QCoapInternalRequest);
-    d->timeout = static_cast<int>(timeout);
+    d->timeout = timeout;
 }
 
 /*!
@@ -664,10 +658,10 @@ void QCoapInternalRequest::setTimeout(uint timeout)
     Sets the maximum transmission span for the request. If the request is
     not finished at the end of the transmission span, the request will timeout.
 */
-void QCoapInternalRequest::setMaxTransmissionWait(int duration)
+void QCoapInternalRequest::setMaxTransmissionWait(uint duration)
 {
     Q_D(QCoapInternalRequest);
-    d->maxTransmitWaitTimer->setInterval(duration);
+    d->maxTransmitWaitTimer->setInterval(static_cast<int>(duration));
 }
 
 /*!
diff --git a/src/coap/qcoapinternalrequest_p.h b/src/coap/qcoapinternalrequest_p.h
index e08953e..df22736 100644
--- a/src/coap/qcoapinternalrequest_p.h
+++ b/src/coap/qcoapinternalrequest_p.h
@@ -72,9 +72,9 @@ public:
     QByteArray toQByteArray() const;
     void setMessageId(quint16);
     void setToken(const QCoapToken&);
-    void setToRequestBlock(int blockNumber, int blockSize);
-    void setToSendBlock(int blockNumber, int blockSize);
-    bool checkBlockNumber(int blockNumber);
+    void setToRequestBlock(uint blockNumber, uint blockSize);
+    void setToSendBlock(uint blockNumber, uint blockSize);
+    bool checkBlockNumber(uint blockNumber);
 
     using QCoapInternalMessage::addOption;
     void addOption(const QCoapOption &option) Q_DECL_OVERRIDE;
@@ -87,14 +87,14 @@ public:
     bool isObserveCancelled() const;
     bool isMulticast() const;
     QCoapConnection *connection() const;
-    int retransmissionCounter() const;
+    uint retransmissionCounter() const;
     void setMethod(QtCoap::Method method);
     void setConnection(QCoapConnection *connection);
     void setObserveCancelled();
 
     void setTargetUri(QUrl targetUri);
     void setTimeout(uint timeout);
-    void setMaxTransmissionWait(int timeout);
+    void setMaxTransmissionWait(uint timeout);
     void setMulticastTimeout(uint responseDelay);
     void restartTransmission();
     void startMulticastTransmission();
@@ -123,8 +123,8 @@ public:
     QCoapConnection *connection = nullptr;
     QByteArray fullPayload;
 
-    int timeout = 0;
-    int retransmissionCounter = 0;
+    uint timeout = 0;
+    uint retransmissionCounter = 0;
     QTimer *timeoutTimer = nullptr;
     QTimer *maxTransmitWaitTimer = nullptr;
     QTimer *multicastExpireTimer = nullptr;
diff --git a/src/coap/qcoapprotocol.cpp b/src/coap/qcoapprotocol.cpp
index fc5e4eb..bdcb15c 100644
--- a/src/coap/qcoapprotocol.cpp
+++ b/src/coap/qcoapprotocol.cpp
@@ -139,7 +139,7 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
         // The timeout interval is chosen based on
         // https://tools.ietf.org/html/rfc7390#section-2.5
         internalRequest->setMulticastTimeout(nonConfirmLifetime()
-                                             + static_cast<uint>(maxLatency())
+                                             + maxLatency()
                                              + maxServerResponseDelay());
     }
 
@@ -917,7 +917,7 @@ bool QCoapProtocolPrivate::isMessageIdRegistered(quint16 id) const
 
     \sa minTimeout(), setAckTimeout()
 */
-int QCoapProtocol::ackTimeout() const
+uint QCoapProtocol::ackTimeout() const
 {
     Q_D(const QCoapProtocol);
     return d->ackTimeout;
@@ -942,7 +942,7 @@ double QCoapProtocol::ackRandomFactor() const
 
     \sa setMaxRetransmit()
 */
-int QCoapProtocol::maxRetransmit() const
+uint QCoapProtocol::maxRetransmit() const
 {
     Q_D(const QCoapProtocol);
     return d->maxRetransmit;
@@ -967,12 +967,9 @@ quint16 QCoapProtocol::blockSize() const
     It is the maximum time from the first transmission of a Confirmable
     message to its last retransmission.
 */
-int QCoapProtocol::maxTransmitSpan() const
+uint QCoapProtocol::maxTransmitSpan() const
 {
-    if (maxRetransmit() <= 0)
-        return 0;
-
-    return static_cast<int>(ackTimeout() * (1u << (maxRetransmit() - 1)) * ackRandomFactor());
+    return static_cast<uint>(ackTimeout() * (1u << (maxRetransmit() - 1)) * ackRandomFactor());
 }
 
 /*!
@@ -983,13 +980,10 @@ int QCoapProtocol::maxTransmitSpan() const
     message to the time when the sender gives up on receiving an
     acknowledgment or reset.
 */
-int QCoapProtocol::maxTransmitWait() const
+uint QCoapProtocol::maxTransmitWait() const
 {
-    if (maxRetransmit() <= 0 || ackTimeout() <= 0)
-        return 0;
-
-    return static_cast<int>(static_cast<unsigned int>(ackTimeout())
-                            * ((1u << (maxRetransmit() + 1)) - 1) * ackRandomFactor());
+    return static_cast<uint>(ackTimeout() * ((1u << (maxRetransmit() + 1)) - 1)
+                             * ackRandomFactor());
 }
 
 /*!
@@ -1000,7 +994,7 @@ int QCoapProtocol::maxTransmitWait() const
     It is the maximum time a datagram is expected to take from the start of
     its transmission to the completion of its reception.
 */
-constexpr int QCoapProtocol::maxLatency()
+constexpr uint QCoapProtocol::maxLatency()
 {
     return 100 * 1000;
 }
@@ -1012,7 +1006,7 @@ constexpr int QCoapProtocol::maxLatency()
 
     \sa ackTimeout(), setAckTimeout()
 */
-int QCoapProtocol::minTimeout() const
+uint QCoapProtocol::minTimeout() const
 {
     Q_D(const QCoapProtocol);
     return d->ackTimeout;
@@ -1023,10 +1017,10 @@ int QCoapProtocol::minTimeout() const
 
     \sa maxTimeout(), setAckTimeout(), setAckRandomFactor()
 */
-int QCoapProtocol::maxTimeout() const
+uint QCoapProtocol::maxTimeout() const
 {
     Q_D(const QCoapProtocol);
-    return static_cast<int>(d->ackTimeout * d->ackRandomFactor);
+    return static_cast<uint>(d->ackTimeout * d->ackRandomFactor);
 }
 
 /*!
@@ -1038,7 +1032,7 @@ int QCoapProtocol::maxTimeout() const
 */
 uint QCoapProtocol::nonConfirmLifetime() const
 {
-    return static_cast<uint>(maxTransmitSpan() + maxLatency());
+    return maxTransmitSpan() + maxLatency();
 }
 
 /*!
@@ -1066,7 +1060,7 @@ uint QCoapProtocol::maxServerResponseDelay() const
 
     \sa ackTimeout(), setAckRandomFactor(), minTimeout(), maxTimeout()
 */
-void QCoapProtocol::setAckTimeout(int ackTimeout)
+void QCoapProtocol::setAckTimeout(uint ackTimeout)
 {
     Q_D(QCoapProtocol);
     d->ackTimeout = ackTimeout;
@@ -1095,13 +1089,9 @@ void QCoapProtocol::setAckRandomFactor(double ackRandomFactor)
 
     \sa maxRetransmit()
 */
-void QCoapProtocol::setMaxRetransmit(int maxRetransmit)
+void QCoapProtocol::setMaxRetransmit(uint maxRetransmit)
 {
     Q_D(QCoapProtocol);
-    if (maxRetransmit < 0) {
-        qWarning("QtCoap: Max retransmit cannot be negative.");
-        return;
-    }
 
     if (maxRetransmit > 25) {
         qWarning("QtCoap: Max retransmit count is capped at 25.");
diff --git a/src/coap/qcoapprotocol.h b/src/coap/qcoapprotocol.h
index afe9930..4f37366 100644
--- a/src/coap/qcoapprotocol.h
+++ b/src/coap/qcoapprotocol.h
@@ -51,16 +51,16 @@ public:
     explicit QCoapProtocol(QObject *parent = nullptr);
     ~QCoapProtocol();
 
-    int ackTimeout() const;
+    uint ackTimeout() const;
     double ackRandomFactor() const;
-    int maxRetransmit() const;
+    uint maxRetransmit() const;
     quint16 blockSize() const;
-    int maxTransmitSpan() const;
-    int maxTransmitWait() const;
-    static constexpr int maxLatency();
+    uint maxTransmitSpan() const;
+    uint maxTransmitWait() const;
+    static constexpr uint maxLatency();
 
-    int minTimeout() const;
-    int maxTimeout() const;
+    uint minTimeout() const;
+    uint maxTimeout() const;
 
     uint nonConfirmLifetime() const;
     uint maxServerResponseDelay() const;
@@ -74,9 +74,9 @@ Q_SIGNALS:
     void error(QCoapReply *reply, QtCoap::Error error);
 
 public Q_SLOTS:
-    void setAckTimeout(int ackTimeout);
+    void setAckTimeout(uint ackTimeout);
     void setAckRandomFactor(double ackRandomFactor);
-    void setMaxRetransmit(int maxRetransmit);
+    void setMaxRetransmit(uint maxRetransmit);
     void setBlockSize(quint16 blockSize);
     void setMaxServerResponseDelay(uint responseDelay);
 
diff --git a/src/coap/qcoapprotocol_p.h b/src/coap/qcoapprotocol_p.h
index 24fa744..602ef73 100644
--- a/src/coap/qcoapprotocol_p.h
+++ b/src/coap/qcoapprotocol_p.h
@@ -105,10 +105,10 @@ public:
     CoapExchangeMap exchangeMap;
     quint16 blockSize = 0;
 
-    int maxRetransmit = 4;
-    int ackTimeout = 2000;
-    double ackRandomFactor = 1.5;
+    uint maxRetransmit = 4;
+    uint ackTimeout = 2000;
     uint maxServerResponseDelay = 250 * 1000;
+    double ackRandomFactor = 1.5;
 
     Q_DECLARE_PUBLIC(QCoapProtocol)
 };