Simplify credentials implementation

examples/addressbook/addressbookengine.cpp

@@ -39,10 +39,9 @@ using namespace qtprotobuf::examples;
 class AuthCredentials : public qtprotobuf::CallCredentials
 {
 public:
-    AuthCredentials(const QString &userName, const QString &password) {
-        callCredentials_p = [userName, password]() { return CredentialMap{{QLatin1String("user-name"), QVariant::fromValue(userName)},
-                            {QLatin1String("user-password"), QVariant::fromValue(password)}}; };
-    }
+    AuthCredentials(const QString &userName, const QString &password) :
+        CallCredentials(CredentialMap{{QLatin1String("user-name"), QVariant::fromValue(userName)},
+                                      {QLatin1String("user-password"), QVariant::fromValue(password)}}) {}
 };
 
 AddressBookEngine::AddressBookEngine() : QObject()

src/grpc/abstractcredentials.h

@@ -55,45 +55,42 @@ public:
     using CredentialMap = QHash<QLatin1String, QVariant>;
 
     CredentialMap callCredentials() {
-        if (callCredentials_p) {
-            return callCredentials_p();
-        }
-        return CredentialMap();
+        return mCallCredentials;
     }
 
     CredentialMap channelCredentials() {
-        if (channelCredentials_p) {
-            return channelCredentials_p();
-        }
-        return CredentialMap();
+        return mChannelCredentials;
     }
 protected:
     AbstractCredentials() = default;
+    void setCallCredentials(const CredentialMap& credentialMap) { mCallCredentials = credentialMap; }
+    void setChannelCredentials(const CredentialMap& credentialMap) { mChannelCredentials = credentialMap; }
 
+private:
     using CredentialsFunction = std::function<CredentialMap(void)>;
-    CredentialsFunction callCredentials_p;
-    CredentialsFunction channelCredentials_p;
+    CredentialMap mCallCredentials;
+    CredentialMap mChannelCredentials;
 };
 
 class CallCredentials : public AbstractCredentials
 {
 protected:
-    CallCredentials() {
-        channelCredentials_p = [](){ return CredentialMap(); };
+    CallCredentials(const CredentialMap& credentialMap) {
+        setCallCredentials(credentialMap);
+        setChannelCredentials(CredentialMap{});
     }
 
 private:
-    using AbstractCredentials::channelCredentials_p;
+    CallCredentials() = default;
 };
 
 class ChannelCredentials : public AbstractCredentials
 {
 protected:
-    ChannelCredentials() {
-        callCredentials_p = [](){ return CredentialMap(); };
+    ChannelCredentials(const CredentialMap& credentialMap) {
+        setCallCredentials(CredentialMap{});
+        setChannelCredentials(credentialMap);
     }
-private:
-    using AbstractCredentials::callCredentials_p;
 };
 
 template<typename Call, typename Channel,
@@ -101,22 +98,22 @@ template<typename Call, typename Channel,
                                    && std::is_base_of<qtprotobuf::ChannelCredentials, Channel>::value, int> = 0>
 AbstractCredentials::AbstractCredentials(const Call &call, const Channel &channel)
 {
-    callCredentials_p = call.callCredentials_p;
-    channelCredentials_p = channel.channelCredentials_p;
+    mCallCredentials = call.mCallCredentials;
+    mChannelCredentials = channel.mChannelCredentials;
 }
 
 template<typename Call,
          typename std::enable_if_t<std::is_base_of<qtprotobuf::CallCredentials, Call>::value, int> = 0>
 AbstractCredentials::AbstractCredentials(const Call &call)
 {
-    callCredentials_p = call.callCredentials_p;
+    mCallCredentials = call.mCallCredentials;
 }
 
 template<typename Channel,
          typename std::enable_if_t<std::is_base_of<qtprotobuf::ChannelCredentials, Channel>::value, int> = 0>
 AbstractCredentials::AbstractCredentials(const Channel &channel)
 {
-    channelCredentials_p = channel.channelCredentials_p;
+    mChannelCredentials = channel.mChannelCredentials;
 }
 }
 

src/grpc/insecurecredentials.h

@@ -32,9 +32,7 @@ namespace qtprotobuf {
 class InsecureCredentials : public ChannelCredentials
 {
 public:
-    InsecureCredentials() {
-        channelCredentials_p = []() { return AbstractCredentials::CredentialMap(); };
-    }
+    InsecureCredentials() : ChannelCredentials(CredentialMap()) {}
 };
 
 }

src/grpc/sslcredentials.h

@@ -34,11 +34,9 @@ namespace qtprotobuf {
 class SslCredentials : public ChannelCredentials
 {
 public:
-    SslCredentials(const QSslConfiguration &configuation) {
-        CredentialMap credentials = CredentialMap{{QLatin1String("sslConfig"),
-                QVariant::fromValue<QSslConfiguration>(configuation)}};
-        channelCredentials_p = [credentials]() { return credentials; };
-    }
+    SslCredentials(const QSslConfiguration &configuation) :
+        ChannelCredentials(CredentialMap{{QLatin1String("sslConfig"),
+                           QVariant::fromValue<QSslConfiguration>(configuation)}}) {}
 };
 
 }