Change client methods signature

- Client methods return result as bool value
- Move AbstractClient data to pimpl

src/generator/templates.cpp

@@ -132,21 +132,22 @@ const char *Templates::QEnumTemplate = "Q_ENUM($type$)\n";
 
 const char *Templates::ClassDefinitionTemplate = "\nclass $classname$ : public $parent_class$\n"
                                                  "{\n";
-const char *Templates::ClientMethodDeclarationSyncTemplate = "Q_INVOKABLE void $method_name$(const $param_type$ &$param_name$, $return_type$ &$return_name$);\n";
-const char *Templates::ClientMethodDeclarationAsyncTemplate = "Q_INVOKABLE void $method_name$(const $param_type$ &$param_name$, const qtprotobuf::AsyncReply<$return_type$> &reply);\n";
+const char *Templates::ClientMethodDeclarationSyncTemplate = "Q_INVOKABLE bool $method_name$(const $param_type$ &$param_name$, $return_type$ &$return_name$);\n";
+const char *Templates::ClientMethodDeclarationAsyncTemplate = "Q_INVOKABLE bool $method_name$(const $param_type$ &$param_name$, const qtprotobuf::AsyncReply<$return_type$> &reply);\n";
 const char *Templates::ServerMethodDeclarationTemplate = "Q_INVOKABLE virtual $return_type$ $method_name$(const $param_type$ &$param_name$) = 0;\n";
 
 
 const char *Templates::ConstructorDefinitionSyncTemplate = "$classname$::$classname$() : $parent_class$(\"$service_name$\")\n"
                                                            "{\n"
                                                            "}\n";
-const char *Templates::ClientMethodDefinitionSyncTemplate = "void $classname$::$method_name$(const $param_type$ &$param_name$, $return_type$ &$return_name$)\n"
+const char *Templates::ClientMethodDefinitionSyncTemplate = "bool $classname$::$method_name$(const $param_type$ &$param_name$, $return_type$ &$return_name$)\n"
                                                             "{\n"
-                                                            "    call(\"$method_name$\", $param_name$, $return_name$);\n"
+                                                            "    return call(\"$method_name$\", $param_name$, $return_name$);\n"
                                                             "}\n";
-const char *Templates::ClientMethodDefinitionAsyncTemplate = "void $classname$::$method_name$(const $param_type$ &$param_name$, const qtprotobuf::AsyncReply<$return_type$> &reply)\n"
+const char *Templates::ClientMethodDefinitionAsyncTemplate = "bool $classname$::$method_name$(const $param_type$ &$param_name$, const qtprotobuf::AsyncReply<$return_type$> &reply)\n"
                                                              "{\n"
                                                              "    //TODO: call transport method to serialize this method\n"
+                                                             "    return false;"
                                                              "}\n";
 
 const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string> Templates::TypeReflection = {

src/lib/abstractclient.cpp

@@ -25,15 +25,36 @@
 
 #include "abstractclient.h"
 
+namespace qtprotobuf {
+struct AbstractClientPrivate final {
+    AbstractClientPrivate(const QString &service) : service(service) {}
+
+    std::shared_ptr<AbstractChannel> channel;
+    const QString service;
+    AbstractChannel::StatusCodes lastError;
+};
+}
+
 using namespace qtprotobuf;
 
 AbstractClient::AbstractClient(const QString &service, QObject *parent) : QObject(parent)
-  , m_service(service)
+  , d(new AbstractClientPrivate(service))
 {
 
 }
 
 void AbstractClient::attachChannel(std::shared_ptr<AbstractChannel> channel)
 {
-    m_channel = channel;
+    d->channel = channel;
+}
+
+bool AbstractClient::call(const QString &method, const QByteArray& arg, QByteArray& ret)
+{
+    if (!d->channel) {
+        d->lastError = AbstractChannel::Unknown;
+        return false;
+    }
+
+    d->lastError = d->channel->call(method, d->service, arg, ret);
+    return d->lastError != AbstractChannel::Ok;
 }

src/lib/abstractclient.h

@@ -35,6 +35,7 @@
 namespace qtprotobuf {
 
 class AbstractChannel;
+class AbstractClientPrivate;
 
 class AbstractClient : public QObject //TODO: QObject is not really required yet
 {
@@ -45,25 +46,21 @@ protected:
     AbstractClient(const QString &service, QObject *parent = nullptr);
 
     template<typename A, typename R>
-    AbstractChannel::StatusCodes call(const QString &method, const A &arg, R &ret) {
-        if (!m_channel) {
-            return AbstractChannel::Unknown;
-        }
-
+    bool call(const QString &method, const A &arg, R &ret) {
         QByteArray retData;
-        AbstractChannel::StatusCodes status = m_channel->call(method, m_service, arg.serialize(), retData);
-        if (status != AbstractChannel::Ok) {
-            return status;
+        if (call(method, arg.serialize(), retData)) {
+            ret.deserialize(retData.mid(5));
+            return true;
         }
-        ret.deserialize(retData.mid(5));
-        return status;
+        return false;
     }
 
 private:
+    bool call(const QString &method, const QByteArray& arg, QByteArray& ret);
+
     Q_DISABLE_COPY(AbstractClient)
 
-    std::shared_ptr<AbstractChannel> m_channel;
-    QString m_service;
+    AbstractClientPrivate *d;
 };
 
 }

tests/clienttest.cpp

@@ -58,6 +58,6 @@ TEST_F(ClientTest, StringEchoTest)
     SimpleStringMessage result;
     SimpleStringMessage request;
     request.setTestFieldString("Hello beach!");
-    testClient.testMethod(request, result);
-    ASSERT_TRUE(result.testFieldString() == "Hello beach!");
+    ASSERT_TRUE(testClient.testMethod(request, result));
+    ASSERT_STREQ(result.testFieldString().toStdString().c_str(), "Hello beach!");
 }