ThreadManager.hpp

Go to the documentation of this file.

#pragma once
#include "Thread.hpp"
#include <EASTL/unique_ptr.h>
#include <EASTL/string.h>
#include <SFML/System.hpp>
#include "IEvent.hpp"

 
namespace mce::core {
 
    class ThreadManager {
    public:
        struct ThreadInfo {
            Thread* thread;
            eastl::string name;
            std::chrono::steady_clock::time_point startTime, endTime;
            bool finished = false;
        };

        explicit ThreadManager(QEventBus& qBus);

        ~ThreadManager();

        template<typename F>
        Thread* createThread(const eastl::string& name, F func);

        template<typename C>
        Thread* createThread(const eastl::string& name, void(C::* func)(), C* object);

        void launch(Thread* th);

        void launch(const eastl::string& name);

        void waitAll();

        void cleanupFinished();

        void printStats();

        size_t activeCount() const;
 
    private:

        void onThreadFinished(const event::ThreadFinished& e);

        void cleanupFinishedUnlocked();
    private:
        mutable std::mutex mutex;
        eastl::unordered_map<Thread*, ThreadInfo> threads;
        eastl::vector<eastl::unique_ptr<Thread>> threadStorage;
        QEventBus& qBus;
    };
    template<typename F>
    inline Thread* ThreadManager::createThread(const eastl::string& name, F func) {
        auto thread = eastl::make_unique<Thread>(qBus, [this, func, name]() {
            qBus.post(event::ThreadStarted{ nullptr, name });
            func();
            });
 
        Thread* rawThread = thread.get();
 
        std::lock_guard<std::mutex> lock(mutex);
        ThreadInfo ti;
        ti.startTime = std::chrono::steady_clock::now();
        ti.name = name;
        ti.thread = rawThread;
        ti.endTime = {};
        ti.finished = false;
        threads.emplace(rawThread, ti);
 
        threadStorage.push_back(eastl::move(thread));
        return rawThread;
    }
    template<typename C>
    inline Thread* ThreadManager::createThread(const eastl::string& name, void(C::* func)(), C* object) {
        qBus.post(event::ThreadStarted{ nullptr, name });
        auto thread = eastl::make_unique<Thread>(
            qBus,
            func,
            object
        );
 
        Thread* rawThread = thread.get();
        {
            std::lock_guard<std::mutex> lock(mutex);
            threads.emplace(rawThread, ThreadInfo{
                thread,
                name,
                std::chrono::steady_clock::now(),
                {},
                false
                });
        }
 
        threadStorage.push_back(eastl::move(thread));
        return rawThread;
    }
}