src/TaskBasedFlockSim/ThreadPool.h

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include <windows.h>

#include <boost\utility.hpp>
#include <vector>

namespace TaskBasedFlockSim
{

class TaskContext;
class ITask;

class ThreadPool :
        boost::noncopyable
{
public:
        ThreadPool(void);

        ThreadPool(size_t minThreadsCount, size_t maxThreadsCount);

        ~ThreadPool(void);

        void SubmitTasks(TaskContext* context);

private:
        struct TaskCallbackContext
        {
                ThreadPool* m_threadPool;
                ITask* m_task;
                TaskContext* m_context;

                TaskCallbackContext(ThreadPool* threadPool, 
                                                        ITask* task, 
                                                        TaskContext* context)   :       m_threadPool(threadPool), 
                                                                                                                m_task(task),
                                                                                                                m_context(context)
                {
                }

                TaskCallbackContext(const TaskCallbackContext& taskCallbackContext)     :       m_threadPool(taskCallbackContext.m_threadPool), 
                                                                                                                                                                m_task(taskCallbackContext.m_task),
                                                                                                                                                                m_context(taskCallbackContext.m_context)
                {
                }

                TaskCallbackContext& operator=(const TaskCallbackContext& taskCallbackContext)
                {
                        m_threadPool = taskCallbackContext.m_threadPool;
                        m_task = taskCallbackContext.m_task;
                        m_context = taskCallbackContext.m_context;

                        return *this;
                }
        };

        PTP_POOL m_pool;

        std::vector<TaskCallbackContext> m_taskCallbacksContext;

        void SetDefaultThreadsCount(void);

        void SetThreadsCount(size_t minThreadsCount, size_t maxThreadsCount);

        friend VOID CALLBACK TaskCallback(PTP_CALLBACK_INSTANCE instance, PVOID context);
};

}

#endif

---