thread_system_integration.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 <kcenon/logger/logger_export.h>
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
 
// Conditional include for thread_system
// LOGGER_HAS_THREAD_SYSTEM is defined by CMake when thread_system is available
#ifdef LOGGER_HAS_THREAD_SYSTEM
#include <kcenon/thread/core/thread_pool.h>
#endif
 
namespace kcenon::logger::integration {
 
enum class async_backend_type {
    standalone,
 
    thread_pool
};
 
#ifdef LOGGER_HAS_THREAD_SYSTEM
 
class LOGGER_SYSTEM_API thread_system_integration {
public:
    static void enable(std::shared_ptr<kcenon::thread::thread_pool> pool = nullptr);
 
    static void disable();
 
    [[nodiscard]] static bool is_enabled() noexcept;
 
    [[nodiscard]] static async_backend_type get_backend() noexcept;
 
    static void set_thread_pool(std::shared_ptr<kcenon::thread::thread_pool> pool);
 
    [[nodiscard]] static std::shared_ptr<kcenon::thread::thread_pool> get_thread_pool() noexcept;
 
    [[nodiscard]] static bool submit_task(std::function<void()> task);
 
    [[nodiscard]] static std::string get_backend_name() noexcept;
 
private:
    // Prevent instantiation - all methods are static
    thread_system_integration() = delete;
    ~thread_system_integration() = delete;
    thread_system_integration(const thread_system_integration&) = delete;
    thread_system_integration& operator=(const thread_system_integration&) = delete;
 
    // Internal state
    static std::atomic<async_backend_type> current_backend_;
    static std::shared_ptr<kcenon::thread::thread_pool> thread_pool_;
    static std::mutex pool_mutex_;
 
    static std::shared_ptr<kcenon::thread::thread_pool> create_default_pool();
};
 
#else // !LOGGER_HAS_THREAD_SYSTEM
 
class thread_system_integration {
public:
    static void enable() noexcept {
        // No-op: thread_system not available
    }
 
    static void disable() noexcept {
        // No-op: thread_system not available
    }
 
    [[nodiscard]] static constexpr bool is_enabled() noexcept {
        return false;
    }
 
    [[nodiscard]] static constexpr async_backend_type get_backend() noexcept {
        return async_backend_type::standalone;
    }
 
    [[nodiscard]] static bool submit_task(std::function<void()> /*task*/) noexcept {
        return false;
    }
 
    [[nodiscard]] static std::string get_backend_name() noexcept {
        return "standalone";
    }
 
private:
    thread_system_integration() = delete;
    ~thread_system_integration() = delete;
    thread_system_integration(const thread_system_integration&) = delete;
    thread_system_integration& operator=(const thread_system_integration&) = delete;
};
 
#endif // LOGGER_HAS_THREAD_SYSTEM
 
[[nodiscard]] constexpr bool has_thread_system_support() noexcept {
#ifdef LOGGER_HAS_THREAD_SYSTEM
    return true;
#else
    return false;
#endif
}
 
} // namespace kcenon::logger::integration