thread_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "../core/configuration.h"
#include "../../core/concepts.h"
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <future>
#include <memory>
#include <type_traits>
 
// Use common Result pattern from shared header
#include "../core/common_result.h"
 
// Forward declare backend interface
namespace database::integrated::adapters::backends
{
    class thread_backend;
}
 
namespace database
{
namespace integrated
{
namespace adapters
{
 
enum class thread_backend_type
{
    auto_select,  
    fallback,     
    null          
};
 
class thread_adapter
{
public:
    explicit thread_adapter(
        const db_thread_config& config,
        thread_backend_type backend_type = thread_backend_type::auto_select);
 
    ~thread_adapter();
 
    // Non-copyable
    thread_adapter(const thread_adapter&) = delete;
    thread_adapter& operator=(const thread_adapter&) = delete;
 
    // Move constructor only (const reference member prevents move assignment)
    thread_adapter(thread_adapter&&) noexcept;
    thread_adapter& operator=(thread_adapter&&) = delete;
 
    common::VoidResult initialize();
 
    common::VoidResult shutdown();
 
    bool is_initialized() const;
 
    // ═══════════════════════════════════════════════════════════════
    // Task Execution
    // ═══════════════════════════════════════════════════════════════
 
    common::VoidResult execute(std::function<void()> task);
 
    template <typename F, typename... Args>
        requires concepts::SubmittableTask<F, Args...>
    auto submit(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>>;
 
    // ═══════════════════════════════════════════════════════════════
    // Work Completion & Statistics
    // ═══════════════════════════════════════════════════════════════
 
    void wait_for_completion();
 
    bool wait_for_completion_timeout(std::chrono::milliseconds timeout);
 
    std::size_t worker_count() const;
 
    std::size_t queue_size() const;
 
    bool is_idle() const;
 
private:
    static std::unique_ptr<backends::thread_backend> create_backend(
        const db_thread_config& config,
        thread_backend_type backend_type);
 
    const db_thread_config& config_;
    std::unique_ptr<backends::thread_backend> backend_; 
};
 
// ═══════════════════════════════════════════════════════════════
// Template Implementations
// ═══════════════════════════════════════════════════════════════
 
template <typename F, typename... Args>
    requires concepts::SubmittableTask<F, Args...>
auto thread_adapter::submit(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>>
{
    using return_type = std::invoke_result_t<F, Args...>;
 
    auto task = std::make_shared<std::packaged_task<return_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...));
 
    auto result = task->get_future();
 
    execute([task = std::move(task)]() { (*task)(); });
 
    return result;
}
 
} // namespace adapters
} // namespace integrated
} // namespace database