scoped_thread.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_SCOPED_THREAD_HPP__
#define NEFORCE_CORE_ASYNC_SCOPED_THREAD_HPP__

 
#include "NeForce/core/async/stop_token.hpp"
NEFORCE_BEGIN_NAMESPACE__



class scoped_thread {
public:
    using id = thread::id;                                 
    using native_handle_type = thread::native_handle_type; 
 
private:
    template <typename Callable, typename Object, typename... Args>
    static constexpr bool pmf_expects_stop_token =
            conjunction_v<is_member_function_pointer<remove_reference_t<Callable>>,
                          is_invocable<Callable, Object, stop_token, Args...>>;
 
    stop_source stop_source_{none};
    thread thread_{};
 
    template <typename Callable, typename Object, typename... Args,
              enable_if_t<pmf_expects_stop_token<Callable, Args...>, int> = 0>
    static thread create(stop_source& source, Callable func, Object&& object, Args&&... args) {
        return thread{func, _NEFORCE forward<Object>(object), source.get_token(), _NEFORCE forward<Args>(args)...};
    }
 
    template <typename Callable, typename... Args,
              enable_if_t<!pmf_expects_stop_token<Callable, Args...> &&
                                  is_invocable_v<decay_t<Callable>, stop_token, decay_t<Args>...>,
                          int> = 0>
    static thread create(stop_source& source, Callable func, Args&&... args) {
        return thread{_NEFORCE forward<Callable>(func), source.get_token(), _NEFORCE forward<Args>(args)...};
    }
 
    template <typename Callable, typename... Args,
              enable_if_t<!pmf_expects_stop_token<Callable, Args...> &&
                                  !is_invocable_v<decay_t<Callable>, stop_token, decay_t<Args>...>,
                          int> = 0>
    static thread create(stop_source&, Callable func, Args&&... args) {
        static_assert(is_invocable_v<decay_t<Callable>, decay_t<Args>...>,
                      "jthread arguments must be invocable after conversion to rvalues");
        return thread{_NEFORCE forward<Callable>(func), _NEFORCE forward<Args>(args)...};
    }
 
public:
    scoped_thread() noexcept = default;

    template <typename Callable, typename... Args,
              typename = enable_if_t<!is_same_v<remove_cvref_t<Callable>, scoped_thread>>>
    explicit scoped_thread(Callable&& func, Args&&... args) :
    thread_{this->create(stop_source_, _NEFORCE forward<Callable>(func), _NEFORCE forward<Args>(args)...)} {}
 
    scoped_thread(const scoped_thread&) = delete;            
    scoped_thread& operator=(const scoped_thread&) = delete; 

    scoped_thread(scoped_thread&& other) noexcept = default;

    scoped_thread& operator=(scoped_thread&& other) noexcept {
        scoped_thread(move(other)).swap(*this);
        return *this;
    }

    ~scoped_thread() {
        if (joinable()) {
            request_stop();
            join();
        }
    }

    void swap(scoped_thread& other) noexcept {
        _NEFORCE swap(stop_source_, other.stop_source_);
        _NEFORCE swap(thread_, other.thread_);
    }

    NEFORCE_NODISCARD bool joinable() const noexcept { return thread_.joinable(); }

    void join() { thread_.join(); }

    void detach() { thread_.detach(); }

    NEFORCE_NODISCARD id get_id() const noexcept { return thread_.get_id(); }

    NEFORCE_NODISCARD native_handle_type native_handle() const { return thread_.native_handle(); }

    NEFORCE_NODISCARD stop_source get_stop_source() noexcept { return stop_source_; }

    NEFORCE_NODISCARD stop_token get_stop_token() const noexcept { return stop_source_.get_token(); }

    bool request_stop() noexcept { return stop_source_.request_stop(); }
};
 // Thread
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_SCOPED_THREAD_HPP__