typed_job_interface.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 "forward_declarations.h"
#include "type_traits.h"
#include <kcenon/thread/core/error_handling.h>
#include <string>
#include <memory>
 
namespace kcenon::thread {
 
    template<detail::JobType job_type>
    class typed_job_interface {
    public:
        virtual ~typed_job_interface() = default;
        
        [[nodiscard]] virtual job_type type() const noexcept = 0;
        
        [[nodiscard]] virtual common::VoidResult execute() = 0;
        
        [[nodiscard]] virtual std::string description() const = 0;
        
        [[nodiscard]] virtual bool is_ready() const noexcept {
            return true; // Default implementation - job is always ready
        }
        
        [[nodiscard]] virtual bool is_cancelled() const noexcept {
            return false; // Default implementation - job is not cancellable
        }
        
        virtual bool cancel() noexcept {
            return false; // Default implementation - job cannot be cancelled
        }
        
        [[nodiscard]] virtual uint64_t estimated_execution_time_us() const noexcept {
            return 0; // Default implementation - unknown execution time
        }
        
        [[nodiscard]] virtual bool has_higher_priority(const typed_job_interface& other) const noexcept {
            return detail::higher_priority(type(), other.type());
        }
    };
    
    template<detail::JobType job_type>
    using typed_job_ptr = std::shared_ptr<typed_job_interface<job_type>>;
    
    template<detail::JobType job_type>
    using typed_job_weak_ptr = std::weak_ptr<typed_job_interface<job_type>>;
    
    template<detail::JobType job_type>
    class typed_job_factory_interface {
    public:
        virtual ~typed_job_factory_interface() = default;
        
        template<detail::JobCallable F>
        [[nodiscard]] virtual typed_job_ptr<job_type> create_job(
            job_type type,
            F&& callback,
            const std::string& description = "callback_job"
        ) = 0;
        
        virtual void cleanup() noexcept {}
    };
    
} // namespace kcenon::thread