#include "threadpool.hpp"

void func(...)
{
    ...
}

constexpr int threadCount = 4;
ThreadPool tp(threadCount);

std::function<void()> task = std::bind(func, ...);
tp.pushTask(task);

tp.pushTask(std::function<void()> { [](){ ... } });

#include "threadpool.hpp"
#include "myFuture.hpp"

template <typename T>
void func_my_promise(ReturnObjectDelivery<T> promise, ...)
{
    ...
    T ret = a + b;
    promise.set_value(ret);
}

constexpr int threadCount = 4;
constexpr int taskCount = 4;
ThreadPool tp(threadCount);

std::vector<ReturnObject<int>> futures(taskCount);

ReturnObjectDelivery<int> promise;
futures[i].connectToROD(&promise);

std::function<void()> task = std::bind(func_my_promise<int>, promise, ...);
tp.pushTask(task);

ReturnObjectDelivery<int> promise;
futures[i].connectToROD(&promise);

std::function<void()> task = [promise, ...]() { func_my_promise<int>(promise, ...); };
tp.pushTask(task);

auto ret = futures[idx].get();

#include "threadpool.hpp"
#include <future>

template <typename T>
T func_std_package(T a, T b, std::mutex *mtxCout)
{
    ...
    T ret = a + b;
    return ret;
}

constexpr int threadCount = 4;
constexpr int taskCount = 4;
ThreadPool tp(threadCount);

std::vector<std::future<int>> futures;

auto sp_packaged_task = std::make_shared<std::packaged_task<int()>>(
    std::bind(func_std_package<int>, a, b, &(tp.mtxCout)));

futures.emplace_back(sp_packaged_task->get_future());

std::function<void()> task = [sp_packaged_task](){ (*sp_packaged_task)(); };
tp.pushTask(task);

auto ret = futures[idx].get();