AsynchronousFunction.h

#pragma once
 
#include <functional>
#include <type_traits>
 
#include <QObject>
 
class QThread;
 
namespace knowCore
{
  namespace details
  {
    class AsynchronousFunctionCall : public QObject
    {
      Q_OBJECT
    public slots:
      void call(void* arg)
      {
        m_function(arg);
      }
      void setFunction(const std::function<void(void*)>& _function) { m_function = _function; }
    private:
      std::function<void(void*)> m_function;
    };
  }
  template<typename... _Args_>
  class AsynchronousFunction
  {
    typedef std::tuple<std::decay_t<_Args_>...> ArgsTuple;
  public:
    AsynchronousFunction(const std::function<void(_Args_...)>& _function, QThread* _thread) : m_call(new details::AsynchronousFunctionCall)
    {
      m_call->moveToThread(_thread);
      m_call->setFunction([_function](void* _args)
      {
        ArgsTuple* args = reinterpret_cast<ArgsTuple*>(_args);
        std::apply(_function, *args);
        delete args;
      });
    }
    ~AsynchronousFunction()
    {
      delete m_call;
    }
    void operator()(_Args_... _args)
    {
      ArgsTuple* t = new ArgsTuple(/*std::make_tuple<details::remove_cvref<_Args_...>>(*/_args...)/*)*/;
      QMetaObject::invokeMethod(m_call, "call", Qt::QueuedConnection, Q_ARG(void*, t));
    }
  private:
    details::AsynchronousFunctionCall* m_call;
  };
}