thread_impl.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 <memory>
#include <atomic>
 
#ifdef USE_STD_JTHREAD
#include <thread>
#include <stop_token>
#else
#include <thread>
#endif
 
namespace kcenon::thread::detail {
    class thread_impl {
    public:
        #ifdef USE_STD_JTHREAD
            using thread_type = std::jthread;
            using stop_token_type = std::stop_token;
            using stop_source_type = std::stop_source;
        #else
            using thread_type = std::thread;
            using stop_token_type = std::atomic<bool>;
            using stop_source_type = std::atomic<bool>;
        #endif
 
        thread_impl() = default;
        ~thread_impl() = default;
 
        thread_impl(const thread_impl&) = delete;
        thread_impl& operator=(const thread_impl&) = delete;
        thread_impl(thread_impl&&) = default;
        thread_impl& operator=(thread_impl&&) = default;
 
        template<typename F>
        void start_thread(F&& func) {
            #ifdef USE_STD_JTHREAD
                stop_source_ = std::make_unique<stop_source_type>();
                thread_ = std::make_unique<thread_type>([func = std::forward<F>(func), this](std::stop_token st) {
                    func(st);
                });
            #else
                stop_requested_ = std::make_unique<stop_token_type>(false);
                thread_ = std::make_unique<thread_type>([func = std::forward<F>(func), this]() {
                    func(*stop_requested_);
                });
            #endif
        }
 
        void request_stop() {
            #ifdef USE_STD_JTHREAD
                if (stop_source_) {
                    stop_source_->request_stop();
                }
            #else
                if (stop_requested_) {
                    stop_requested_->store(true);
                }
            #endif
        }
 
        [[nodiscard]] bool stop_requested() const {
            #ifdef USE_STD_JTHREAD
                return stop_source_ && stop_source_->stop_requested();
            #else
                return stop_requested_ && stop_requested_->load();
            #endif
        }
 
        void join() {
            if (thread_ && thread_->joinable()) {
                thread_->join();
            }
        }
 
        void detach() {
            if (thread_ && thread_->joinable()) {
                thread_->detach();
            }
        }
 
        [[nodiscard]] bool joinable() const {
            return thread_ && thread_->joinable();
        }
 
    private:
        std::unique_ptr<thread_type> thread_;
        
        #ifdef USE_STD_JTHREAD
            std::unique_ptr<stop_source_type> stop_source_;
        #else
            std::unique_ptr<stop_token_type> stop_requested_;
        #endif
    };
}