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/utils/formatter.h>
#include <kcenon/thread/utils/convert_string.h>
#include "error_handling.h"
#include "cancellation_token.h"
#include "retry_policy.h"
 
#include <tuple>
#include <memory>
#include <string>
#include <vector>
#include <optional>
#include <string_view>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
 
namespace kcenon::thread
{
    class job_queue;
 
    enum class job_priority
    {
        lowest = 0,     
        low = 1,        
        normal = 2,     
        high = 3,       
        highest = 4,    
        realtime = 5    
    };
 
    // Forward declarations for future composition components
    class retry_policy;
 
    struct job_components
    {
        std::function<void(common::VoidResult)> on_complete;
 
        std::function<void(const common::error_info&)> on_error;
 
        std::optional<job_priority> priority;
 
        std::optional<retry_policy> retry;
 
        std::optional<std::chrono::milliseconds> timeout;
 
        bool has_explicit_cancellation{false};
    };
 
    class job
    {
    public:
        [[nodiscard]] auto get_job_id() const -> std::uint64_t { return job_id_; }
 
        [[nodiscard]] auto get_enqueue_time() const -> std::chrono::steady_clock::time_point
        {
            return enqueue_time_;
        }
 
        job(const std::string& name = "job");
 
        job(const std::vector<uint8_t>& data, const std::string& name = "data_job");
 
        virtual ~job(void);
 
        [[nodiscard]] auto get_name(void) const -> std::string;
 
    [[nodiscard]] virtual auto do_work(void) -> common::VoidResult;
    
    virtual auto set_cancellation_token(const cancellation_token& token) -> void;
    
    [[nodiscard]] virtual auto get_cancellation_token() const -> cancellation_token;
 
        virtual auto set_job_queue(const std::shared_ptr<job_queue>& job_queue) -> void;
 
        [[nodiscard]] virtual auto get_job_queue(void) const -> std::shared_ptr<job_queue>;
 
        [[nodiscard]] virtual auto to_string(void) const -> std::string;
 
        // ========================================================================
        // Composition Methods (Fluent Interface)
        // ========================================================================
 
        auto with_on_complete(std::function<void(common::VoidResult)> callback) -> job&;
 
        auto with_on_error(std::function<void(const common::error_info&)> callback) -> job&;
 
        auto with_priority(job_priority priority) -> job&;
 
        auto with_cancellation(const cancellation_token& token) -> job&;
 
        auto with_retry(const retry_policy& policy) -> job&;
 
        auto with_timeout(std::chrono::milliseconds timeout) -> job&;
 
        [[nodiscard]] auto get_priority() const -> job_priority;
 
        [[nodiscard]] auto get_retry_policy() const -> std::optional<retry_policy>;
 
        [[nodiscard]] auto get_timeout() const -> std::optional<std::chrono::milliseconds>;
 
        [[nodiscard]] auto has_explicit_cancellation() const -> bool;
 
        [[nodiscard]] auto has_components() const -> bool;
 
    protected:
        auto invoke_callbacks(const common::VoidResult& result) -> void;
        std::string name_;
 
        std::vector<uint8_t> data_;
 
        std::weak_ptr<job_queue> job_queue_;
 
        cancellation_token cancellation_token_;
 
    private:
        static std::atomic<std::uint64_t> next_job_id_;
 
        std::uint64_t job_id_;
 
        std::chrono::steady_clock::time_point enqueue_time_;
 
        std::unique_ptr<job_components> components_;
 
        auto ensure_components() -> job_components&;
    };
} // namespace kcenon::thread
 
// ----------------------------------------------------------------------------
// Formatter specializations for job
// ----------------------------------------------------------------------------
 
#include <kcenon/thread/utils/formatter_macros.h>
 
// Generate formatter specializations for kcenon::thread::job
DECLARE_FORMATTER(kcenon::thread::job)