Task.h

 
#pragma once
 
#include "core/GpgFrontendCore.h"
#include "core/function/SecureMemoryAllocator.h"
#include "core/model/DataObject.h"
 
namespace GpgFrontend::Thread {
 
class TaskRunner;
 
class GPGFRONTEND_CORE_EXPORT Task : public QObject, public QRunnable {
  Q_OBJECT
 public:
  friend class TaskRunner;
 
  using TaskRunnable = std::function<int(DataObjectPtr)>;        
  using TaskCallback = std::function<void(int, DataObjectPtr)>;  
 
  class TaskHandler {
   public:
    explicit TaskHandler(Task*);
 
    void Start();
 
    void Cancel();
 
    auto GetTask() -> Task*;
 
   private:
    QPointer<Task> task_;
  };
 
  explicit Task(QString name);
 
  explicit Task(TaskRunnable runnable, QString name,
                DataObjectPtr data_object = nullptr);
 
  explicit Task(TaskRunnable runnable, QString name, DataObjectPtr data,
                TaskCallback callback);
 
  ~Task() override;
 
  [[nodiscard]] auto GetUUID() const -> QString;
 
  [[nodiscard]] auto GetFullID() const -> QString;
 
  void HoldOnLifeCycle(bool hold_on);
 
  virtual auto Run() -> int;
 
  [[nodiscard]] auto GetRTN();
 
 public slots:
 
  void SafelyRun();
 
 signals:
 
  void SignalRun();
 
  void SignalTaskShouldEnd(int);
 
  void SignalTaskEnd();
 
 protected:
  void setRTN(int rtn);
 
 private slots:
 
  void slot_exception_safe_run() noexcept;
 
 private:
  class Impl;
  SecureUniquePtr<Impl> p_;
 
  void run() override;
};
}  // namespace GpgFrontend::Thread