ThreadManager.hpp

#pragma once
#ifndef __H__OCULAR_CORE_THREAD_MANAGER__H__
#define __H__OCULAR_CORE_THREAD_MANAGER__H__

#include <future>
#include <thread>
#include <utility>
#include <vector>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        class ThreadManager
        {
        public:

            ThreadManager();
            ~ThreadManager();

            /*template<typename F, typename ... Args>
            inline auto spawnAsync(F&& function, Args&& ... args) -> std::async<F, Args>
            {
                auto result = std::async(std::forward<F>(function), std::forward<Args>(args) ...);

                if (result.wait_for(0) == std::future_status::deferred)
                {
                    // Async task was created as deferred.
                    // Call wait on the future to force it's execution to begin.
                    result.wait();
                }

                return result;
            }*/

            /*template<typename F, typename ... Args>
            inline auto spawnAsyncNow(F&& function, Args&& ... args) -> std::async<F, Args>
            {
                return std::async(std::launch::async, std::forward<F>(function), std::forward<Args>(args) ...);
            }*/

            /*template<typename T, typename ... F>
            inline void waitForAsyncs(F&& ... futures)
            {
                std::vector<std::future<T>*> futuresContainer = { futures ... };

                for (auto iter = futuresContainer.begin(); iter != futuresContainer.end(); ++iter)
                {
                    (*iter)->wait();
                }
            }*/

        protected:

        private:
        };
    }
}

//------------------------------------------------------------------------------------------

#endif