FunctionThread.h

#pragma once

#include "TaskThread.h"

#include <QThread>
#include <QVariant>

#include <optional>

namespace APD
{

template <class ResultType>
class FunctionThread : public TaskThread
{
public:
    using Function = std::function<ResultType(TaskThread*)>;

    FunctionThread(Function func, QObject* parent = nullptr)
        : TaskThread(parent)
        , m_func(std::move(func))
    {}

    std::optional<ResultType> result() const
    {
        std::lock_guard<std::mutex> lck (m_resultMutex);
        return m_result;
    }

protected:

    void run() override
    {
        auto result = m_func(this);
        std::lock_guard<std::mutex> lck (m_resultMutex);
        m_result = std::move(result);
    }

private:
    Q_DISABLE_COPY(FunctionThread)

    Function m_func;
    std::optional<ResultType> m_result;
    mutable std::mutex m_resultMutex;
};

template<>
class  FunctionThread<void>
        : public TaskThread
{
public:
    using Function = std::function<void(TaskThread*)>;

    FunctionThread(Function func, QObject* parent = nullptr)
        : TaskThread(parent)
        , m_func(std::move(func))
    {}

protected:
    void run() override
    {
        m_func(this);
    }

private:
    Q_DISABLE_COPY(FunctionThread<void>)

    Function m_func;
};


};