ThreadPool.hpp

#ifndef AETHER_THREADPOOL_HPP
#define AETHER_THREADPOOL_HPP

#include <condition_variable>
#include <deque>
#include <functional>
#include <mutex>
#include <thread>
#include <vector>

// Forward declare class
namespace Aether {
    class Window;
};

namespace Aether {
    class ThreadPool {
        // Allow the Window class access to the constructor and destructor
        friend Window;

        public:
            // Forward declare nested class
            class Job;

            enum class Importance {
                Normal,     //< Normal importance; queue at end
                High        //< High importance; queue at start
            };

        private:
            struct WorkerMetadata {
                std::condition_variable conditionVariable;      
                std::mutex mutex;                               
                int jobID;                                      
                WorkerMetadata() {
                    this->jobID = 0;
                }
            };

            static ThreadPool * instance;                       
            int nextID;                                         
            bool terminating;                                   
            std::mutex jobsMutex;                               
            std::deque<std::pair<Job *, int>> jobs;             
            std::condition_variable workerConditionVariable;    
            std::vector<WorkerMetadata> workerMetadata;         
            std::vector<std::thread> workers;                   
            ThreadPool();

            void doWork(size_t idx);

            ~ThreadPool();

        public:
            ThreadPool(ThreadPool &) = delete;

            void operator=(const ThreadPool &) = delete;

            static ThreadPool * getInstance();

            size_t maxConcurrentJobs();

            int queueJob(Job * job, const Importance importance);

            void removeOrWaitForJob(int id);
    };
};

#endif