refactor: use c++17 features and piml tech to rewrite DataObject and Task

3 files changed, 63 insertions, 71 deletions

diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp
index dcb188ec..7d5ecc24 100644
--- a/src/core/function/gpg/GpgCommandExecutor.cpp
+++ b/src/core/function/gpg/GpgCommandExecutor.cpp
@@ -27,48 +27,56 @@
  */
 #include "GpgCommandExecutor.h"
 
+#include <memory>
+#include <string>
+
 #include "GpgFunctionObject.h"
 #include "core/thread/TaskRunnerGetter.h"
+#include "thread/DataObject.h"
 
 GpgFrontend::GpgCommandExecutor::GpgCommandExecutor(int channel)
     : SingletonFunctionObject<GpgCommandExecutor>(channel) {}
 
 void GpgFrontend::GpgCommandExecutor::Execute(
     std::string cmd, std::vector<std::string> arguments,
-    std::function<void(int, std::string, std::string)> callback,
-    std::function<void(QProcess *)> interact_func) {
+    GpgCommandExecutorCallback callback,
+    GpgCommandExecutorInteractor interact_func) {
   SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size());
 
   Thread::Task::TaskCallback result_callback =
-      [](int rtn, Thread::Task::DataObjectPtr data_object) {
+      [](int rtn, Thread::DataObjectPtr data_object) {
         SPDLOG_DEBUG("data object use count: {}", data_object.use_count());
-        if (data_object->GetObjectSize() != 4)
+        if (!data_object->Check<int, std::string, std::string>())
           throw std::runtime_error("invalid data object size");
 
-        auto exit_code = data_object->PopObject<int>();
-        auto process_stdout = data_object->PopObject<std::string>();
-        auto process_stderr = data_object->PopObject<std::string>();
-        auto callback = data_object->PopObject<
-            std::function<void(int, std::string, std::string)>>();
+        auto exit_code = Thread::ExtractParams<int>(data_object, 0);
+        auto process_stdout =
+            Thread::ExtractParams<std::string>(data_object, 1);
+        auto process_stderr =
+            Thread::ExtractParams<std::string>(data_object, 2);
+        auto callback =
+            Thread::ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
 
         // call callback
         callback(exit_code, process_stdout, process_stderr);
       };
 
   Thread::Task::TaskRunnable runner =
-      [](GpgFrontend::Thread::Task::DataObjectPtr data_object) -> int {
+      [](Thread::DataObjectPtr data_object) -> int {
     SPDLOG_DEBUG("process runner called, data object size: {}",
                  data_object->GetObjectSize());
 
-    if (data_object->GetObjectSize() != 4)
+    if (!data_object
+             ->Check<std::string, std::string, GpgCommandExecutorInteractor>())
       throw std::runtime_error("invalid data object size");
 
     // get arguments
-    auto cmd = data_object->PopObject<std::string>();
+    auto cmd = Thread::ExtractParams<std::string>(data_object, 0);
     SPDLOG_DEBUG("get cmd: {}", cmd);
-    auto arguments = data_object->PopObject<std::vector<std::string>>();
+    auto arguments =
+        Thread::ExtractParams<std::vector<std::string>>(data_object, 1);
     auto interact_func =
-        data_object->PopObject<std::function<void(QProcess *)>>();
+        Thread::ExtractParams<GpgCommandExecutorInteractor>(data_object, 2);
 
     auto *cmd_process = new QProcess();
     cmd_process->setProcessChannelMode(QProcess::MergedChannels);
@@ -120,27 +128,13 @@ void GpgFrontend::GpgCommandExecutor::Execute(
     cmd_process->close();
     cmd_process->deleteLater();
 
-    // transfer result
-    SPDLOG_DEBUG("runner append object");
-    data_object->AppendObject(std::move(process_stderr));
-    data_object->AppendObject(std::move(process_stdout));
-    data_object->AppendObject(std::move(exit_code));
-    SPDLOG_DEBUG("runner append object done");
-
+    data_object->Swap({exit_code, process_stdout, process_stderr});
     return 0;
   };
 
-  // data transfer into task
-  auto data_object = std::make_shared<Thread::Task::DataObject>();
-  SPDLOG_DEBUG("executor append object");
-  data_object->AppendObject(std::move(callback));
-  data_object->AppendObject(std::move(interact_func));
-  data_object->AppendObject(std::move(arguments));
-  data_object->AppendObject(std::move(std::string{cmd}));
-  SPDLOG_DEBUG("executor append object done");
-
   auto *process_task = new GpgFrontend::Thread::Task(
-      std::move(runner), fmt::format("Execute/{}", cmd), data_object,
+      std::move(runner), fmt::format("Execute/{}", cmd),
+      Thread::TransferParams(cmd, arguments, interact_func, callback),
       std::move(result_callback));
 
   QEventLoop looper;
@@ -158,40 +152,43 @@ void GpgFrontend::GpgCommandExecutor::Execute(
 
 void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
     std::string cmd, std::vector<std::string> arguments,
-    std::function<void(int, std::string, std::string)> callback,
-    std::function<void(QProcess *)> interact_func) {
+    GpgCommandExecutorCallback callback,
+    GpgCommandExecutorInteractor interact_func) {
   SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size());
 
   Thread::Task::TaskCallback result_callback =
-      [](int rtn, Thread::Task::DataObjectPtr data_object) {
-        if (data_object->GetObjectSize() != 4)
+      [](int rtn, Thread::DataObjectPtr data_object) {
+        if (!data_object->Check<int, std::string, std::string,
+                                GpgCommandExecutorCallback>())
           throw std::runtime_error("invalid data object size");
 
-        auto exit_code = data_object->PopObject<int>();
-        auto process_stdout = data_object->PopObject<std::string>();
-        auto process_stderr = data_object->PopObject<std::string>();
-        auto callback = data_object->PopObject<
-            std::function<void(int, std::string, std::string)>>();
+        auto exit_code = Thread::ExtractParams<int>(data_object, 0);
+        auto process_stdout =
+            Thread::ExtractParams<std::string>(data_object, 1);
+        auto process_stderr =
+            Thread::ExtractParams<std::string>(data_object, 2);
+        auto callback =
+            Thread::ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
 
         // call callback
         callback(exit_code, process_stdout, process_stderr);
       };
 
   Thread::Task::TaskRunnable runner =
-      [](GpgFrontend::Thread::Task::DataObjectPtr data_object) -> int {
+      [](GpgFrontend::Thread::DataObjectPtr data_object) -> int {
     SPDLOG_DEBUG("process runner called, data object size: {}",
                  data_object->GetObjectSize());
 
-    if (data_object->GetObjectSize() != 4)
+    if (!data_object
+             ->Check<std::string, std::string, GpgCommandExecutorInteractor>())
       throw std::runtime_error("invalid data object size");
 
-    SPDLOG_DEBUG("runner pop object");
     // get arguments
-    auto cmd = data_object->PopObject<std::string>();
-    auto arguments = data_object->PopObject<std::vector<std::string>>();
+    auto cmd = Thread::ExtractParams<std::string>(data_object, 0);
+    auto arguments =
+        Thread::ExtractParams<std::vector<std::string>>(data_object, 1);
     auto interact_func =
-        data_object->PopObject<std::function<void(QProcess *)>>();
-    SPDLOG_DEBUG("runner pop object done");
+        Thread::ExtractParams<std::function<void(QProcess *)>>(data_object, 2);
 
     auto *cmd_process = new QProcess();
     cmd_process->setProcessChannelMode(QProcess::MergedChannels);
@@ -244,22 +241,13 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
     cmd_process->close();
     cmd_process->deleteLater();
 
-    // transfer result
-    SPDLOG_DEBUG("runner append object");
-    data_object->AppendObject(std::move(process_stderr));
-    data_object->AppendObject(std::move(process_stdout));
-    data_object->AppendObject(std::move(exit_code));
-    SPDLOG_DEBUG("runner append object done");
-
+    data_object->Swap({exit_code, process_stdout, process_stderr});
     return 0;
   };
 
   // data transfer into task
-  auto data_object = std::make_shared<Thread::Task::DataObject>();
-  data_object->AppendObject(std::move(callback));
-  data_object->AppendObject(std::move(interact_func));
-  data_object->AppendObject(std::move(arguments));
-  data_object->AppendObject(std::move(std::string{cmd}));
+  auto data_object =
+      Thread::TransferParams(cmd, arguments, interact_func, callback);
 
   auto *process_task = new GpgFrontend::Thread::Task(
       std::move(runner), fmt::format("ExecuteConcurrently/{}", cmd),
diff --git a/src/core/function/gpg/GpgCommandExecutor.h b/src/core/function/gpg/GpgCommandExecutor.h
index a7259df8..1bad6d40 100644
--- a/src/core/function/gpg/GpgCommandExecutor.h
+++ b/src/core/function/gpg/GpgCommandExecutor.h
@@ -39,6 +39,10 @@
 
 namespace GpgFrontend {
 
+using GpgCommandExecutorCallback =
+    std::function<void(int, std::string, std::string)>;
+using GpgCommandExecutorInteractor = std::function<void(QProcess *)>;
+
 /**
  * @brief Extra commands related to GPG
  *
@@ -62,14 +66,14 @@ class GPGFRONTEND_CORE_EXPORT GpgCommandExecutor
    */
   void Execute(
       std::string cmd, std::vector<std::string> arguments,
-      std::function<void(int, std::string, std::string)> callback =
-          [](int, std::string, std::string) {},
-      std::function<void(QProcess *)> interact_func = [](QProcess *) {});
+      GpgCommandExecutorCallback callback = [](int, std::string,
+                                               std::string) {},
+      GpgCommandExecutorInteractor interact_func = [](QProcess *) {});
 
   void ExecuteConcurrently(
       std::string cmd, std::vector<std::string> arguments,
-      std::function<void(int, std::string, std::string)> callback,
-      std::function<void(QProcess *)> interact_func = [](QProcess *) {});
+      GpgCommandExecutorCallback callback,
+      GpgCommandExecutorInteractor interact_func = [](QProcess *) {});
 
  private:
   GpgContext &ctx_ = GpgContext::GetInstance(
diff --git a/src/core/function/gpg/GpgFileOpera.cpp b/src/core/function/gpg/GpgFileOpera.cpp
index cb919042..de50de62 100644
--- a/src/core/function/gpg/GpgFileOpera.cpp
+++ b/src/core/function/gpg/GpgFileOpera.cpp
@@ -55,7 +55,7 @@ GpgFrontend::GpgError GpgFrontend::GpgFileOpera::EncryptFile(
     throw std::runtime_error("read file error");
   }
 
-  std::unique_ptr<std::string> out_buffer = nullptr;
+  ByteArrayPtr out_buffer = nullptr;
 
   auto err = GpgBasicOperator::GetInstance(_channel).Encrypt(
       std::move(keys), in_buffer, out_buffer, result);
@@ -85,7 +85,7 @@ GpgFrontend::GpgError GpgFrontend::GpgFileOpera::DecryptFile(
   if (!FileOperator::ReadFileStd(in_path_std, in_buffer)) {
     throw std::runtime_error("read file error");
   }
-  std::unique_ptr<std::string> out_buffer;
+  ByteArrayPtr out_buffer;
 
   auto err =
       GpgBasicOperator::GetInstance().Decrypt(in_buffer, out_buffer, result);
@@ -119,7 +119,7 @@ gpgme_error_t GpgFrontend::GpgFileOpera::SignFile(KeyListPtr keys,
   if (!FileOperator::ReadFileStd(in_path_std, in_buffer)) {
     throw std::runtime_error("read file error");
   }
-  std::unique_ptr<std::string> out_buffer;
+  ByteArrayPtr out_buffer;
 
   auto err = GpgBasicOperator::GetInstance(_channel).Sign(
       std::move(keys), in_buffer, out_buffer, GPGME_SIG_MODE_DETACH, result);
@@ -149,7 +149,7 @@ gpgme_error_t GpgFrontend::GpgFileOpera::VerifyFile(
   if (!FileOperator::ReadFileStd(data_path_std, in_buffer)) {
     throw std::runtime_error("read file error");
   }
-  std::unique_ptr<std::string> sign_buffer = nullptr;
+  ByteArrayPtr sign_buffer = nullptr;
   if (!sign_path.empty()) {
     std::string sign_buffer_str;
     if (!FileOperator::ReadFileStd(sign_path_std, sign_buffer_str)) {
@@ -180,7 +180,7 @@ gpg_error_t GpgFrontend::GpgFileOpera::EncryptSignFile(
   if (!FileOperator::ReadFileStd(in_path_std, in_buffer)) {
     throw std::runtime_error("read file error");
   }
-  std::unique_ptr<std::string> out_buffer = nullptr;
+  ByteArrayPtr out_buffer = nullptr;
 
   auto err = GpgBasicOperator::GetInstance(_channel).EncryptSign(
       std::move(keys), std::move(signer_keys), in_buffer, out_buffer, encr_res,
@@ -212,7 +212,7 @@ gpg_error_t GpgFrontend::GpgFileOpera::DecryptVerifyFile(
     throw std::runtime_error("read file error");
   }
 
-  std::unique_ptr<std::string> out_buffer = nullptr;
+  ByteArrayPtr out_buffer = nullptr;
   auto err = GpgBasicOperator::GetInstance().DecryptVerify(
       in_buffer, out_buffer, decr_res, verify_res);
 
@@ -241,7 +241,7 @@ unsigned int GpgFrontend::GpgFileOpera::EncryptFileSymmetric(
     throw std::runtime_error("read file error");
   }
 
-  std::unique_ptr<std::string> out_buffer;
+  ByteArrayPtr out_buffer;
   auto err = GpgBasicOperator::GetInstance(_channel).EncryptSymmetric(
       in_buffer, out_buffer, result);