lazy_thread.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_LAZY_THREAD_HPP__
#define NEFORCE_CORE_ASYNC_LAZY_THREAD_HPP__

 
#include "NeForce/core/async/thread.hpp"
#include "NeForce/core/functional/function.hpp"
NEFORCE_BEGIN_NAMESPACE__



class NEFORCE_API lazy_thread {
public:
    using id = thread::id;                                 
    using native_handle_type = thread::native_handle_type; 
 
private:
    function<void()> func_; 
    thread thread_;         
 
public:
    lazy_thread() noexcept = default;

    template <typename F, typename... Args>
    explicit lazy_thread(F&& f, Args&&... args) {
        func_ = [func = _NEFORCE forward<F>(f), args = _NEFORCE make_tuple(_NEFORCE forward<Args>(args)...)]() mutable {
            _NEFORCE apply(_NEFORCE move(func), _NEFORCE move(args));
        };
    }
 
    lazy_thread(const lazy_thread&) = delete;
    lazy_thread& operator=(const lazy_thread&) = delete;

    lazy_thread(lazy_thread&& other) noexcept;

    lazy_thread& operator=(lazy_thread&& other) noexcept;

    ~lazy_thread();

    void start();

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

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

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

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

    void swap(lazy_thread& other) noexcept {
        _NEFORCE swap(func_, other.func_);
        _NEFORCE swap(thread_, other.thread_);
    }
};
 // Thread
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_LAZY_THREAD_HPP__