dag_job_builder.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 "dag_job.h"
 
#include <functional>
#include <initializer_list>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace kcenon::thread
{
    class dag_job_builder
    {
    public:
        explicit dag_job_builder(const std::string& name = "dag_job");
 
        dag_job_builder(dag_job_builder&&) noexcept = default;
 
        auto operator=(dag_job_builder&&) noexcept -> dag_job_builder& = default;
 
        dag_job_builder(const dag_job_builder&) = delete;
 
        auto operator=(const dag_job_builder&) -> dag_job_builder& = delete;
 
        ~dag_job_builder() = default;
 
        auto work(std::function<common::VoidResult()> callable) -> dag_job_builder&;
 
        template<typename T>
        auto work_with_result(std::function<common::Result<T>()> callable) -> dag_job_builder&
        {
            work_with_result_func_ = [func = std::move(callable)](dag_job& job) -> common::VoidResult {
                auto result = func();
                if (result.is_ok())
                {
                    job.set_result(result.value());
                    return common::ok();
                }
                return common::VoidResult(result.error());
            };
            return *this;
        }
 
        template<typename T>
        auto returns() -> dag_job_builder&
        {
            has_return_type_ = true;
            return *this;
        }
 
        auto depends_on(job_id dependency) -> dag_job_builder&;
 
        auto depends_on(std::initializer_list<job_id> dependencies) -> dag_job_builder&;
 
        auto depends_on(const std::vector<job_id>& dependencies) -> dag_job_builder&;
 
        auto on_failure(std::function<common::VoidResult()> fallback) -> dag_job_builder&;
 
        [[nodiscard]] auto is_valid() const -> bool;
 
        [[nodiscard]] auto get_validation_error() const -> std::optional<std::string>;
 
        [[nodiscard]] auto build() -> std::unique_ptr<dag_job>;
 
        auto reset() -> dag_job_builder&;
 
    private:
        std::string name_;
        std::function<common::VoidResult()> work_func_;
        std::function<common::VoidResult(dag_job&)> work_with_result_func_;
        std::function<common::VoidResult()> fallback_func_;
        std::vector<job_id> dependencies_;
        bool has_return_type_{false};
    };
 
} // namespace kcenon::thread