Task.h

 
#ifndef GPGFRONTEND_TASK_H
#define GPGFRONTEND_TASK_H
 
#include <functional>
#include <memory>
#include <stack>
#include <string>
#include <type_traits>
#include <utility>
 
#include "core/GpgFrontendCore.h"
 
namespace GpgFrontend::Thread {
 
class TaskRunner;
 
class GPGFRONTEND_CORE_EXPORT Task : public QObject, public QRunnable {
  Q_OBJECT
 public:
  class DataObject;
  using DataObjectPtr = std::shared_ptr<DataObject>;             
  using TaskRunnable = std::function<int(DataObjectPtr)>;        
  using TaskCallback = std::function<void(int, DataObjectPtr)>;  
 
  friend class TaskRunner;
 
  class GPGFRONTEND_CORE_EXPORT DataObject {
   public:
    struct Destructor {
      const void *p_obj;
      void (*destroy)(const void *);
    };
 
    size_t GetObjectSize();
 
    template <typename T>
    void AppendObject(T &&obj) {
      DLOG(TRACE) << "called:" << this;
      auto *obj_dstr = this->get_heap_ptr(sizeof(T));
      new ((void *)obj_dstr->p_obj) T(std::forward<T>(obj));
 
      if (std::is_class_v<T>) {
        auto destructor = [](const void *x) {
          static_cast<const T *>(x)->~T();
        };
        obj_dstr->destroy = destructor;
      } else {
        obj_dstr->destroy = nullptr;
      }
 
      data_objects_.push(obj_dstr);
    }
 
    template <typename T>
    void AppendObject(T *obj) {
      DLOG(TRACE) << "called:" << this;
      auto *obj_dstr = this->get_heap_ptr(sizeof(T));
      auto *ptr_heap = new ((void *)obj_dstr->p_obj) T(std::move(*obj));
      if (std::is_class_v<T>) {
        LOG(TRACE) << "is class";
        auto destructor = [](const void *x) {
          static_cast<const T *>(x)->~T();
        };
        obj_dstr->destroy = destructor;
      } else {
        obj_dstr->destroy = nullptr;
      }
      data_objects_.push(std::move(obj_dstr));
    }
 
    template <typename T>
    T PopObject() {
      DLOG(TRACE) << "called:" << this;
      if (data_objects_.empty()) throw std::runtime_error("No object to pop");
      auto *obj_dstr = data_objects_.top();
      auto *heap_ptr = (T *)obj_dstr->p_obj;
      auto obj = std::move(*(T *)(heap_ptr));
      this->free_heap_ptr(obj_dstr);
      data_objects_.pop();
      return obj;
    }
 
    ~DataObject();
 
   private:
    std::stack<Destructor *> data_objects_;  
 
    Destructor *get_heap_ptr(size_t bytes_size);
 
    void free_heap_ptr(Destructor *);
  };
 
  Task();
 
  explicit Task(TaskCallback callback, DataObjectPtr data_object = nullptr);
 
  explicit Task(
      TaskRunnable runnable,
      TaskCallback callback = [](int, const std::shared_ptr<DataObject> &) {},
      DataObjectPtr data = nullptr);
 
  virtual ~Task() override;
 
  virtual void Run();
 
  std::string GetUUID() const;
 
 signals:
  void SignalTaskFinished();
 
  void SignalTaskPostFinishedDone();
 
 protected:
  void SetFinishAfterRun(bool finish_after_run);
 
  void SetRTN(int rtn);
 
 private:
  const std::string uuid_;
  TaskCallback callback_;                
  TaskRunnable runnable_;                
  bool finish_after_run_ = true;         
  int rtn_ = 0;                          
  QThread *callback_thread_ = nullptr;   
  DataObjectPtr data_object_ = nullptr;  
 
  void before_finish_task();
 
  void init();
 
  virtual void run() override;
 
  static std::string generate_uuid();
};
}  // namespace GpgFrontend::Thread
 
#endif  // GPGFRONTEND_TASK_H