jthread_compat.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/common/config/feature_flags.h>
#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
 
#if KCENON_HAS_JTHREAD
    #include <stop_token>
#endif
 
// Legacy alias for backward compatibility
#ifndef LOGGER_HAS_JTHREAD
    #define LOGGER_HAS_JTHREAD KCENON_HAS_JTHREAD
#endif
 
namespace kcenon::logger::async {
 
class simple_stop_source {
public:
    simple_stop_source() : stopped_(false) {}
 
    void request_stop() {
        stopped_.store(true, std::memory_order_release);
    }
 
    [[nodiscard]] bool stop_requested() const noexcept {
        return stopped_.load(std::memory_order_acquire);
    }
 
    void reset() {
        stopped_.store(false, std::memory_order_release);
    }
 
private:
    std::atomic<bool> stopped_;
};
 
class compat_jthread {
public:
    compat_jthread() noexcept = default;
 
#if KCENON_HAS_JTHREAD
    template<typename F>
    explicit compat_jthread(F&& func)
        : thread_(std::forward<F>(func)) {}
#else
    template<typename F>
    explicit compat_jthread(F&& func)
        : stop_source_(std::make_shared<simple_stop_source>())
        , thread_([func = std::forward<F>(func), stop = stop_source_]() {
            func(*stop);
        }) {}
#endif
 
    ~compat_jthread() {
        if (joinable()) {
            request_stop();
            join();
        }
    }
 
    // Non-copyable
    compat_jthread(const compat_jthread&) = delete;
    compat_jthread& operator=(const compat_jthread&) = delete;
 
    // Movable
    compat_jthread(compat_jthread&& other) noexcept
#if KCENON_HAS_JTHREAD
        : thread_(std::move(other.thread_)) {}
#else
        : stop_source_(std::move(other.stop_source_))
        , thread_(std::move(other.thread_)) {}
#endif
 
    compat_jthread& operator=(compat_jthread&& other) noexcept {
        if (this != &other) {
            if (joinable()) {
                request_stop();
                join();
            }
#if KCENON_HAS_JTHREAD
            thread_ = std::move(other.thread_);
#else
            stop_source_ = std::move(other.stop_source_);
            thread_ = std::move(other.thread_);
#endif
        }
        return *this;
    }
 
    [[nodiscard]] bool joinable() const noexcept {
#if KCENON_HAS_JTHREAD
        return thread_.joinable();
#else
        return thread_.joinable();
#endif
    }
 
    void request_stop() {
#if KCENON_HAS_JTHREAD
        thread_.request_stop();
#else
        if (stop_source_) {
            stop_source_->request_stop();
        }
#endif
    }
 
    void join() {
#if KCENON_HAS_JTHREAD
        if (thread_.joinable()) {
            thread_.join();
        }
#else
        if (thread_.joinable()) {
            thread_.join();
        }
#endif
    }
 
#if !KCENON_HAS_JTHREAD
    [[nodiscard]] std::shared_ptr<simple_stop_source> get_stop_source() const noexcept {
        return stop_source_;
    }
#endif
 
private:
#if KCENON_HAS_JTHREAD
    std::jthread thread_;
#else
    std::shared_ptr<simple_stop_source> stop_source_;
    std::thread thread_;
#endif
};
 
class compat_cv_wait {
public:
#if KCENON_HAS_JTHREAD
    template<typename Lock, typename Predicate>
    static bool wait(std::condition_variable_any& cv,
                     Lock& lock,
                     std::stop_token stop,
                     Predicate pred) {
        return cv.wait(lock, stop, pred);
    }
#else
    template<typename Lock, typename Predicate>
    static bool wait(std::condition_variable& cv,
                     Lock& lock,
                     simple_stop_source& stop,
                     Predicate pred) {
        cv.wait(lock, [&]() {
            return stop.stop_requested() || pred();
        });
        return !stop.stop_requested() && pred();
    }
#endif
};
 
} // namespace kcenon::logger::async