Thread.hpp

Go to the documentation of this file.

#pragma once
#include "QEventBus.hpp"

 
namespace mce::core {
    class ThreadImpl;

    struct ThreadFunc {
        virtual ~ThreadFunc() {}

        virtual void run() = 0;
    };

    template<typename F>
    struct ThreadFunctor : ThreadFunc {
        ThreadFunctor(F functor) : functor(functor) {}

        virtual void run() override { functor(); };

        F functor;
    };

    template<typename C>
    struct ThreadMemberFunctor : ThreadFunc {
        ThreadMemberFunctor(void(C::* function)(), C* object) : functor(function), object(object) {}

        virtual void run() override { functor(); };

        void(C::* functor)();

        C* object;
    };

    template<typename C, typename... Args>
    struct ThreadMemberFunctorWithArgs : ThreadFunc {
        ThreadMemberFunctorWithArgs(void(C::* function)(Args...), C* object, Args&&... args) : functor(functor), object(object) {}

        virtual void run() override {
            call(std::index_sequence_for<Args...>{});
        }

        void(C::* functor)(Args...);

        C* object;

        std::tuple<Args...> args;
    private:
        template <std::size_t... I>
        void call(std::index_sequence<I...>) {
            (object->*functor)(std::get<I>(args)...);
        }
    };

    class Thread {
    public:
        template<typename F>
        Thread(QEventBus& qBus, F function);

        template<typename C>
        Thread(QEventBus& qBus, void(C::* function)(), C* object);

        template<typename C, typename... Args>
        Thread(QEventBus& qBus, void(C::* function)(), C* object, Args&&... args);

        ~Thread();

        void launch();

        void wait();
 
    private:
        friend class ThreadImpl;

        void run();

        ThreadImpl* pImpl;//pointer to implementation

        ThreadFunc* entryPoint;

        QEventBus& qBus;
    };
    template<typename F>
    inline Thread::Thread(QEventBus& qBus, F function) :
        pImpl(nullptr),
        entryPoint(new ThreadFunctor<F>(function)),
        qBus(qBus) {
 
    }
    template<typename C>
    inline Thread::Thread(QEventBus& qBus, void(C::* function)(), C* object) :
        pImpl(nullptr),
        entryPoint(new ThreadMemberFunctor<C>(function, object)),
        qBus(qBus) {
 
    }
    template<typename C, typename ...Args>
    inline Thread::Thread(QEventBus& qBus, void(C::* function)(), C* object, Args && ...args) : 
        pImpl(nullptr),
        entryPoint(new ThreadMemberFunctorWithArgs<C>(function, object)),
        qBus(qBus) {
 
    }
}