task_group.hpp

Go to the documentation of this file.

#pragma once

 
#include <exception>
#include <future>
#include <mutex>
#include <vector>
 
namespace threadschedule
{

template <typename Pool>
class task_group
{
  public:
    explicit task_group(Pool& pool) : pool_(pool) {}
 
    task_group(task_group const&) = delete;
    auto operator=(task_group const&) -> task_group& = delete;
 
    ~task_group()
    {
        try
        {
            wait();
        }
        catch (...)
        {
        }
    }

    template <typename F>
    void submit(F&& f)
    {
        auto future = pool_.submit(std::forward<F>(f));
        std::lock_guard<std::mutex> lock(mutex_);
        futures_.push_back(std::move(future));
    }

    void wait()
    {
        std::vector<std::future<void>> local;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            local.swap(futures_);
        }
 
        std::exception_ptr first_error;
        for (auto& f : local)
        {
            try
            {
                f.get();
            }
            catch (...)
            {
                if (!first_error)
                    first_error = std::current_exception();
            }
        }
 
        if (first_error)
            std::rethrow_exception(first_error);
    }

    [[nodiscard]] auto pending() const -> size_t
    {
        std::lock_guard<std::mutex> lock(mutex_);
        return futures_.size();
    }
 
  private:
    Pool& pool_;
    mutable std::mutex mutex_;
    std::vector<std::future<void>> futures_;
};
 
} // namespace threadschedule