future_job.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/thread/core/job.h>
#include <kcenon/thread/core/error_handling.h>
 
#include <functional>
#include <future>
#include <memory>
#include <type_traits>
 
namespace kcenon::thread {
 
template<typename R>
class future_job : public job {
public:
    template<typename F,
             typename = std::enable_if_t<std::is_invocable_r_v<R, F>>>
    explicit future_job(F&& callable, const std::string& name = "future_job")
        : job(name)
        , callable_(std::forward<F>(callable))
        , promise_(std::make_shared<std::promise<R>>())
    {}
 
    [[nodiscard]] auto get_future() -> std::future<R> {
        return promise_->get_future();
    }
 
protected:
    [[nodiscard]] auto do_work() -> common::VoidResult override {
        // Check for cancellation before starting
        if (cancellation_token_.is_cancelled()) {
            promise_->set_exception(
                std::make_exception_ptr(
                    std::runtime_error("Job cancelled before execution")
                )
            );
            return make_error_result(error_code::operation_canceled);
        }
 
        try {
            if constexpr (std::is_void_v<R>) {
                callable_();
                promise_->set_value();
            } else {
                promise_->set_value(callable_());
            }
        } catch (...) {
            promise_->set_exception(std::current_exception());
            return make_error_result(
                error_code::job_execution_failed,
                "Exception thrown during job execution"
            );
        }
 
        return common::ok();
    }
 
private:
    std::function<R()> callable_;
    std::shared_ptr<std::promise<R>> promise_;
};
 
} // namespace kcenon::thread