job.cpp

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.
 
#include <kcenon/thread/core/job.h>
 
#include <kcenon/thread/core/job_queue.h>
 
using namespace utility_module;
 
namespace kcenon::thread
{
    // Initialize static member for job ID generation
    std::atomic<std::uint64_t> job::next_job_id_{0};
 
    job::job(const std::string& name)
        : name_(name)
        , data_(std::vector<uint8_t>())
        , job_id_(next_job_id_.fetch_add(1, std::memory_order_relaxed))
        , enqueue_time_(std::chrono::steady_clock::now())
    {
    }
 
    job::job(const std::vector<uint8_t>& data, const std::string& name)
        : name_(name)
        , data_(data)
        , job_id_(next_job_id_.fetch_add(1, std::memory_order_relaxed))
        , enqueue_time_(std::chrono::steady_clock::now())
    {
    }
 
    job::~job(void) {}
 
    auto job::get_name(void) const -> std::string { return name_; }
 
    auto job::do_work(void) -> common::VoidResult {
        // Base implementation indicates missing override in derived class
        // This should never be called in production code
        return common::error_info{static_cast<int>(error_code::not_implemented), "job::do_work() must be implemented in derived class", "thread_system"};
    }
 
    auto job::set_cancellation_token(const cancellation_token& token) -> void {
        cancellation_token_ = token;
    }
 
    auto job::get_cancellation_token() const -> cancellation_token {
        return cancellation_token_;
    }
 
    auto job::set_job_queue(const std::shared_ptr<job_queue>& job_queue) -> void
    {
        job_queue_ = job_queue;
    }
 
    auto job::get_job_queue(void) const -> std::shared_ptr<job_queue> { return job_queue_.lock(); }
 
    auto job::to_string(void) const -> std::string { return formatter::format("job: {}", name_); }
 
    // ========================================================================
    // Composition Methods Implementation
    // ========================================================================
 
    auto job::ensure_components() -> job_components&
    {
        if (!components_)
        {
            components_ = std::make_unique<job_components>();
        }
        return *components_;
    }
 
    auto job::with_on_complete(std::function<void(common::VoidResult)> callback) -> job&
    {
        ensure_components().on_complete = std::move(callback);
        return *this;
    }
 
    auto job::with_on_error(std::function<void(const common::error_info&)> callback) -> job&
    {
        ensure_components().on_error = std::move(callback);
        return *this;
    }
 
    auto job::with_priority(job_priority priority) -> job&
    {
        ensure_components().priority = priority;
        return *this;
    }
 
    auto job::with_cancellation(const cancellation_token& token) -> job&
    {
        cancellation_token_ = token;
        ensure_components().has_explicit_cancellation = true;
        return *this;
    }
 
    auto job::with_retry(const retry_policy& policy) -> job&
    {
        ensure_components().retry = policy;
        return *this;
    }
 
    auto job::with_timeout(std::chrono::milliseconds timeout) -> job&
    {
        ensure_components().timeout = timeout;
        return *this;
    }
 
    auto job::get_priority() const -> job_priority
    {
        if (components_ && components_->priority.has_value())
        {
            return components_->priority.value();
        }
        return job_priority::normal;
    }
 
    auto job::get_retry_policy() const -> std::optional<retry_policy>
    {
        if (components_ && components_->retry.has_value())
        {
            return components_->retry;
        }
        return std::nullopt;
    }
 
    auto job::get_timeout() const -> std::optional<std::chrono::milliseconds>
    {
        if (components_ && components_->timeout.has_value())
        {
            return components_->timeout;
        }
        return std::nullopt;
    }
 
    auto job::has_explicit_cancellation() const -> bool
    {
        return components_ && components_->has_explicit_cancellation;
    }
 
    auto job::has_components() const -> bool
    {
        return components_ != nullptr;
    }
 
    auto job::invoke_callbacks(const common::VoidResult& result) -> void
    {
        if (!components_)
        {
            return;
        }
 
        // Invoke error callback first if result is an error
        if (result.is_err() && components_->on_error)
        {
            components_->on_error(result.error());
        }
 
        // Always invoke on_complete callback if set
        if (components_->on_complete)
        {
            components_->on_complete(result);
        }
    }
} // namespace kcenon::thread