Rename d-pointers in QtProtobuf code

- Rename d_ptr to dPtr to avoid variable shadowing
TODO: It's temporaru solution. For classes that inherited of
      QObject, it's probably better to use Q_DECLARE_PRIVATE

src/grpc/qabstractgrpcclient.cpp

@@ -46,7 +46,7 @@ public:
 using namespace QtProtobuf;
 
 QAbstractGrpcClient::QAbstractGrpcClient(const QString &service, QObject *parent) : QObject(parent)
-  , d_ptr(std::make_unique<QAbstractGrpcClientPrivate>(service))
+  , dPtr(std::make_unique<QAbstractGrpcClientPrivate>(service))
 {
 }
 
@@ -55,15 +55,15 @@ QAbstractGrpcClient::~QAbstractGrpcClient()
 
 void QAbstractGrpcClient::attachChannel(const std::shared_ptr<QAbstractGrpcChannel> &channel)
 {
-    d_ptr->channel = channel;
-    d_ptr->serializer = channel->serializer();
+    dPtr->channel = channel;
+    dPtr->serializer = channel->serializer();
 }
 
 QGrpcStatus QAbstractGrpcClient::call(const QString &method, const QByteArray &arg, QByteArray &ret)
 {
     QGrpcStatus callStatus{QGrpcStatus::Unknown};
-    if (d_ptr->channel) {
-        callStatus = d_ptr->channel->call(method, d_ptr->service, arg, ret);
+    if (dPtr->channel) {
+        callStatus = dPtr->channel->call(method, dPtr->service, arg, ret);
     } else {
         callStatus = QGrpcStatus{QGrpcStatus::Unknown, QLatin1String("No channel(s) attached.")};
     }
@@ -78,8 +78,8 @@ QGrpcStatus QAbstractGrpcClient::call(const QString &method, const QByteArray &a
 QGrpcAsyncReply *QAbstractGrpcClient::call(const QString &method, const QByteArray &arg)
 {
     QGrpcAsyncReply *reply = nullptr;
-    if (d_ptr->channel) {
-        reply = new QGrpcAsyncReply(d_ptr->channel, this);
+    if (dPtr->channel) {
+        reply = new QGrpcAsyncReply(dPtr->channel, this);
 
         connect(reply, &QGrpcAsyncReply::error, this, [this, reply](const QGrpcStatus &status) {
             error(status);
@@ -90,7 +90,7 @@ QGrpcAsyncReply *QAbstractGrpcClient::call(const QString &method, const QByteArr
             reply->deleteLater();
         });
 
-        d_ptr->channel->call(method, d_ptr->service, arg, reply);
+        dPtr->channel->call(method, dPtr->service, arg, reply);
     } else {
         error({QGrpcStatus::Unknown, QLatin1String("No channel(s) attached.")});
     }
@@ -100,8 +100,8 @@ QGrpcAsyncReply *QAbstractGrpcClient::call(const QString &method, const QByteArr
 
 void QAbstractGrpcClient::subscribe(const QString &method, const QByteArray &arg, const std::function<void(const QByteArray&)> &handler)
 {
-    if (d_ptr->channel) {
-        d_ptr->channel->subscribe(method, d_ptr->service, arg, this, handler);
+    if (dPtr->channel) {
+        dPtr->channel->subscribe(method, dPtr->service, arg, this, handler);
     } else {
         error({QGrpcStatus::Unknown, QLatin1String("No channel(s) attached.")});
     }
@@ -109,5 +109,5 @@ void QAbstractGrpcClient::subscribe(const QString &method, const QByteArray &arg
 
 QAbstractProtobufSerializer *QAbstractGrpcClient::serializer() const
 {
-    return d_ptr->serializer.get();
+    return dPtr->serializer.get();
 }

src/grpc/qabstractgrpcclient.h

@@ -206,6 +206,6 @@ private:
 
     Q_DISABLE_COPY_MOVE(QAbstractGrpcClient)
 
-    std::unique_ptr<QAbstractGrpcClientPrivate> d_ptr;
+    std::unique_ptr<QAbstractGrpcClientPrivate> dPtr;
 };
 }

src/grpc/qgrpchttp2channel.cpp

@@ -196,7 +196,7 @@ struct QGrpcHttp2ChannelPrivate {
 }
 
 QGrpcHttp2Channel::QGrpcHttp2Channel(const QUrl &url, std::unique_ptr<QAbstractGrpcCredentials> credentials) : QAbstractGrpcChannel()
-  , d_ptr(std::make_unique<QGrpcHttp2ChannelPrivate>(url, std::move(credentials)))
+  , dPtr(std::make_unique<QGrpcHttp2ChannelPrivate>(url, std::move(credentials)))
 {
 }
 
@@ -208,7 +208,7 @@ QGrpcStatus QGrpcHttp2Channel::call(const QString &method, const QString &servic
 {
     QEventLoop loop;
 
-    QNetworkReply *networkReply = d_ptr->post(method, service, args);
+    QNetworkReply *networkReply = dPtr->post(method, service, args);
     QObject::connect(networkReply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
 
     //If reply was finished in same stack it doesn't make sense to start event loop
@@ -217,7 +217,7 @@ QGrpcStatus QGrpcHttp2Channel::call(const QString &method, const QString &servic
     }
 
     QGrpcStatus::StatusCode grpcStatus = QGrpcStatus::StatusCode::Unknown;
-    ret = d_ptr->processReply(networkReply, grpcStatus);
+    ret = dPtr->processReply(networkReply, grpcStatus);
 
     qProtoDebug() << __func__ << "RECV: " << ret.toHex() << "grpcStatus" << grpcStatus;
     return {grpcStatus, QString::fromUtf8(networkReply->rawHeader(GrpcStatusMessage))};
@@ -225,7 +225,7 @@ QGrpcStatus QGrpcHttp2Channel::call(const QString &method, const QString &servic
 
 void QGrpcHttp2Channel::call(const QString &method, const QString &service, const QByteArray &args, QtProtobuf::QGrpcAsyncReply *reply)
 {
-    QNetworkReply *networkReply = d_ptr->post(method, service, args);
+    QNetworkReply *networkReply = dPtr->post(method, service, args);
 
     auto connection = QObject::connect(networkReply, &QNetworkReply::finished, reply, [reply, networkReply]() {
         QGrpcStatus::StatusCode grpcStatus = QGrpcStatus::StatusCode::Unknown;
@@ -249,15 +249,15 @@ void QGrpcHttp2Channel::call(const QString &method, const QString &service, cons
 
 void QGrpcHttp2Channel::subscribe(const QString &method, const QString &service, const QByteArray &args, QAbstractGrpcClient *client, const std::function<void (const QByteArray &)> &handler)
 {
-    QNetworkReply *networkReply = d_ptr->post(method, service, args, true);
+    QNetworkReply *networkReply = dPtr->post(method, service, args, true);
 
-    auto connection = QObject::connect(networkReply, &QNetworkReply::readyRead, &(d_ptr->lambdaContext), [networkReply, handler, this]() {
-        auto replyIt = d_ptr->activeStreamReplies.find(networkReply);
+    auto connection = QObject::connect(networkReply, &QNetworkReply::readyRead, &(dPtr->lambdaContext), [networkReply, handler, this]() {
+        auto replyIt = dPtr->activeStreamReplies.find(networkReply);
 
         QByteArray data = networkReply->readAll();
         qProtoDebug() << "RECV" << data.size();
 
-        if (replyIt == d_ptr->activeStreamReplies.end()) {
+        if (replyIt == dPtr->activeStreamReplies.end()) {
             qProtoDebug() << data.toHex();
             int expectedDataSize = QGrpcHttp2ChannelPrivate::getExpectedDataSize(data);
             qProtoDebug() << "First chunk received: " << data.size() << " expectedDataSize: " << expectedDataSize;
@@ -268,7 +268,7 @@ void QGrpcHttp2Channel::subscribe(const QString &method, const QString &service,
             }
 
             QGrpcHttp2ChannelPrivate::ExpectedData dataContainer{expectedDataSize, QByteArray{}};
-            replyIt = d_ptr->activeStreamReplies.insert({networkReply, dataContainer}).first;
+            replyIt = dPtr->activeStreamReplies.insert({networkReply, dataContainer}).first;
         }
 
         QGrpcHttp2ChannelPrivate::ExpectedData &dataContainer = replyIt->second;
@@ -287,21 +287,21 @@ void QGrpcHttp2Channel::subscribe(const QString &method, const QString &service,
         }
 
         if (dataContainer.container.size() < GrpcMessageSizeHeaderSize) {
-            d_ptr->activeStreamReplies.erase(replyIt);
+            dPtr->activeStreamReplies.erase(replyIt);
         }
     });
 
     QObject::connect(client, &QAbstractGrpcClient::destroyed, networkReply, [networkReply, connection, this]() {
-        d_ptr->activeStreamReplies.erase(networkReply);
+        dPtr->activeStreamReplies.erase(networkReply);
         QObject::disconnect(connection);
         QGrpcHttp2ChannelPrivate::abortNetworkReply(networkReply);
     });
 
-    QObject::connect(networkReply, &QNetworkReply::finished, &(d_ptr->lambdaContext), [method, service, args, client, handler, networkReply, connection, this]() {
+    QObject::connect(networkReply, &QNetworkReply::finished, &(dPtr->lambdaContext), [method, service, args, client, handler, networkReply, connection, this]() {
         QString errorString = networkReply->errorString();
         QNetworkReply::NetworkError networkError = networkReply->error();
 
-        d_ptr->activeStreamReplies.erase(networkReply);
+        dPtr->activeStreamReplies.erase(networkReply);
         QObject::disconnect(connection);
         QGrpcHttp2ChannelPrivate::abortNetworkReply(networkReply);
 

src/grpc/qgrpchttp2channel.h

@@ -55,6 +55,6 @@ protected:
 private:
     Q_DISABLE_COPY_MOVE(QGrpcHttp2Channel)
 
-    std::unique_ptr<QGrpcHttp2ChannelPrivate> d_ptr;
+    std::unique_ptr<QGrpcHttp2ChannelPrivate> dPtr;
 };
 }

src/grpc/qgrpcstatus.cpp

@@ -40,26 +40,26 @@ public:
 };
 
 QGrpcStatus::QGrpcStatus(StatusCode code, const QString &message) :
-    d_ptr(std::make_unique<QGrpcStatusPrivate>(code, message))
+    dPtr(std::make_unique<QGrpcStatusPrivate>(code, message))
 {}
 
-QGrpcStatus::QGrpcStatus(const QGrpcStatus &other) : d_ptr(std::make_unique<QGrpcStatusPrivate>(other.d_ptr->m_code, other.d_ptr->m_message))
+QGrpcStatus::QGrpcStatus(const QGrpcStatus &other) : dPtr(std::make_unique<QGrpcStatusPrivate>(other.dPtr->m_code, other.dPtr->m_message))
 {}
 
-QGrpcStatus::QGrpcStatus(QGrpcStatus &&other) : d_ptr(std::move(other.d_ptr))
+QGrpcStatus::QGrpcStatus(QGrpcStatus &&other) : dPtr(std::move(other.dPtr))
 {
 }
 
 QGrpcStatus &QGrpcStatus::operator =(const QGrpcStatus &other)
 {
-    d_ptr->m_code = other.d_ptr->m_code;
-    d_ptr->m_message = other.d_ptr->m_message;
+    dPtr->m_code = other.dPtr->m_code;
+    dPtr->m_message = other.dPtr->m_message;
     return *this;
 }
 
 QGrpcStatus &QGrpcStatus::operator =(QGrpcStatus &&other)
 {
-    d_ptr = std::move(other.d_ptr);
+    dPtr = std::move(other.dPtr);
     return *this;
 }
 
@@ -68,27 +68,27 @@ QGrpcStatus::~QGrpcStatus()
 
 QString QGrpcStatus::message() const
 {
-    return d_ptr->m_message;
+    return dPtr->m_message;
 }
 
 QGrpcStatus::StatusCode QGrpcStatus::code() const
 {
-    return d_ptr->m_code;
+    return dPtr->m_code;
 }
 
 bool QGrpcStatus::operator ==(StatusCode code) const
 {
-    return d_ptr->m_code == code;
+    return dPtr->m_code == code;
 }
 
 bool QGrpcStatus::operator !=(StatusCode code) const
 {
-    return d_ptr->m_code != code;
+    return dPtr->m_code != code;
 }
 
 bool QGrpcStatus::operator ==(const QGrpcStatus &other) const
 {
-    return d_ptr->m_code == other.d_ptr->m_code;
+    return dPtr->m_code == other.dPtr->m_code;
 }
 
 }

src/grpc/qgrpcstatus.h

@@ -92,7 +92,7 @@ public:
     QGrpcStatus &operator =(QGrpcStatus &&other);
 
 private:
-    std::unique_ptr<QGrpcStatusPrivate> d_ptr;
+    std::unique_ptr<QGrpcStatusPrivate> dPtr;
 };
 }
 

src/protobuf/qprotobufjsonserializer.cpp

@@ -56,7 +56,7 @@ private:
 
 }
 
-QProtobufJsonSerializer::QProtobufJsonSerializer() : d_ptr(new QProtobufJsonSerializerPrivate(this))
+QProtobufJsonSerializer::QProtobufJsonSerializer() : dPtr(new QProtobufJsonSerializerPrivate(this))
 {
 }
 
@@ -74,7 +74,7 @@ QByteArray QProtobufJsonSerializer::serializeMessage(const QObject *object, cons
         QMetaProperty metaProperty = metaObject.staticMetaObject.property(propertyIndex);
         const char *propertyName = metaProperty.name();
         const QVariant &propertyValue = object->property(propertyName);
-        result.append(d_ptr->serializeProperty(propertyValue, QProtobufMetaProperty(metaProperty, fieldIndex)));
+        result.append(dPtr->serializeProperty(propertyValue, QProtobufMetaProperty(metaProperty, fieldIndex)));
     }
 
     result.append("}");

src/protobuf/qprotobufjsonserializer.h

@@ -61,7 +61,7 @@ protected:
     void deserializeEnum(int64 &value, const QMetaEnum &metaEnum, QProtobufSelfcheckIterator &it) const override;
     void deserializeEnumList(QList<int64> &value, const QMetaEnum &metaEnum, QProtobufSelfcheckIterator &it) const override;
 private:
-    std::unique_ptr<QProtobufJsonSerializerPrivate> d_ptr;
+    std::unique_ptr<QProtobufJsonSerializerPrivate> dPtr;
 };
 
 }

src/protobuf/qprotobufserializer.cpp

@@ -74,7 +74,7 @@ void QProtobufSerializerPrivate::deserializeList<QString>(QProtobufSelfcheckIter
 
 QProtobufSerializer::~QProtobufSerializer() = default;
 
-QProtobufSerializer::QProtobufSerializer() : d_ptr(new QProtobufSerializerPrivate(this))
+QProtobufSerializer::QProtobufSerializer() : dPtr(new QProtobufSerializerPrivate(this))
 {
 }
 
@@ -88,7 +88,7 @@ QByteArray QProtobufSerializer::serializeMessage(const QObject *object, const QP
         QMetaProperty metaProperty = metaObject.staticMetaObject.property(propertyIndex);
         const char *propertyName = metaProperty.name();
         const QVariant &propertyValue = object->property(propertyName);
-        result.append(d_ptr->serializeProperty(propertyValue, QProtobufMetaProperty(metaProperty, fieldIndex)));
+        result.append(dPtr->serializeProperty(propertyValue, QProtobufMetaProperty(metaProperty, fieldIndex)));
     }
 
     return result;
@@ -97,7 +97,7 @@ QByteArray QProtobufSerializer::serializeMessage(const QObject *object, const QP
 void QProtobufSerializer::deserializeMessage(QObject *object, const QProtobufMetaObject &metaObject, const QByteArray &data) const
 {
     for (QProtobufSelfcheckIterator it(data); it != data.end();) {
-        d_ptr->deserializeProperty(object, metaObject, it);
+        dPtr->deserializeProperty(object, metaObject, it);
     }
 }
 
@@ -127,13 +127,13 @@ void QProtobufSerializer::deserializeListObject(QObject *object, const QProtobuf
 QByteArray QProtobufSerializer::serializeMapPair(const QVariant &key, const QVariant &value, const QProtobufMetaProperty &metaProperty) const
 {
     QByteArray result = QProtobufSerializerPrivate::encodeHeader(metaProperty.protoFieldIndex(), LengthDelimited);
-    result.append(QProtobufSerializerPrivate::prependLengthDelimitedSize(d_ptr->serializeProperty(key, QProtobufMetaProperty(metaProperty, 1)) + d_ptr->serializeProperty(value, QProtobufMetaProperty(metaProperty, 2))));
+    result.append(QProtobufSerializerPrivate::prependLengthDelimitedSize(dPtr->serializeProperty(key, QProtobufMetaProperty(metaProperty, 1)) + dPtr->serializeProperty(value, QProtobufMetaProperty(metaProperty, 2))));
     return result;
 }
 
 void QProtobufSerializer::deserializeMapPair(QVariant &key, QVariant &value, QProtobufSelfcheckIterator &it) const
 {
-    d_ptr->deserializeMapPair(key, value, it);
+    dPtr->deserializeMapPair(key, value, it);
 }
 
 QByteArray QProtobufSerializer::serializeEnum(int64 value, const QMetaEnum &/*metaEnum*/, const QtProtobuf::QProtobufMetaProperty &metaProperty) const

src/protobuf/qprotobufserializer.h

@@ -60,7 +60,7 @@ protected:
     void deserializeEnum(int64 &value, const QMetaEnum &metaEnum, QProtobufSelfcheckIterator &it) const override;
     void deserializeEnumList(QList<int64> &value, const QMetaEnum &metaEnum, QProtobufSelfcheckIterator &it) const override;
 
-    std::unique_ptr<QProtobufSerializerPrivate> d_ptr;
+    std::unique_ptr<QProtobufSerializerPrivate> dPtr;
 };
 
 }