thread.h

#ifndef UVW_THREAD_INCLUDE_H
#define UVW_THREAD_INCLUDE_H
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <uv.h>
#include "config.h"
#include "enum.hpp"
#include "loop.h"
#include "uv_type.hpp"
 
namespace uvw {
 
namespace details {
 
enum class uvw_thread_create_flags : std::underlying_type_t<uv_thread_create_flags> {
    THREAD_NO_FLAGS = UV_THREAD_NO_FLAGS,
    THREAD_HAS_STACK_SIZE = UV_THREAD_HAS_STACK_SIZE
};
 
}
 
class thread;
class thread_local_storage;
class once;
class mutex;
class rwlock;
class semaphore;
class condition;
class barrier;
 
class thread final: public uv_type<uv_thread_t> {
    using internal_task = std::function<void(std::shared_ptr<void>)>;
 
    static void create_callback(void *arg);
 
public:
    using create_flags = details::uvw_thread_create_flags;
    using task = internal_task;
    using type = uv_thread_t;
 
    explicit thread(loop::token token, std::shared_ptr<loop> ref, task t, std::shared_ptr<void> d = nullptr) noexcept;
 
    static type self() noexcept;
 
    static int getcpu() noexcept;
 
    static bool equal(const thread &tl, const thread &tr) noexcept;
 
    ~thread() noexcept;
 
    bool run() noexcept;
 
    bool run(create_flags opts, std::size_t stack = {}) noexcept;
 
    bool join() noexcept;
 
private:
    std::shared_ptr<void> data;
    task func;
};
 
class thread_local_storage final: public uv_type<uv_key_t> {
public:
    explicit thread_local_storage(loop::token token, std::shared_ptr<loop> ref) noexcept;
 
    ~thread_local_storage() noexcept;
 
    template<typename T>
    T *get() noexcept {
        return static_cast<T *>(uv_key_get(uv_type::raw()));
    }
 
    template<typename T>
    void set(T *value) noexcept {
        return uv_key_set(uv_type::raw(), value);
    }
};
 
class once final: public uv_type<uv_once_t> {
    static uv_once_t *guard() noexcept;
 
public:
    using uv_type::uv_type;
 
    template<typename F>
    static void run(F &&f) noexcept {
        using callback_type = void (*)(void);
        static_assert(std::is_convertible_v<F, callback_type>);
        callback_type cb = f;
        uv_once(guard(), cb);
    }
};
 
class mutex final: public uv_type<uv_mutex_t> {
    friend class condition;
 
public:
    explicit mutex(loop::token token, std::shared_ptr<loop> ref, bool recursive = false) noexcept;
 
    ~mutex() noexcept;
 
    void lock() noexcept;
 
    bool try_lock() noexcept;
 
    void unlock() noexcept;
};
 
class rwlock final: public uv_type<uv_rwlock_t> {
public:
    explicit rwlock(loop::token token, std::shared_ptr<loop> ref) noexcept;
 
    ~rwlock() noexcept;
 
    void rdlock() noexcept;
 
    bool try_rdlock() noexcept;
 
    void rdunlock() noexcept;
 
    void wrlock() noexcept;
 
    bool try_wrlock() noexcept;
 
    void wrunlock() noexcept;
};
 
class semaphore final: public uv_type<uv_sem_t> {
public:
    explicit semaphore(loop::token token, std::shared_ptr<loop> ref, unsigned int value) noexcept;
 
    ~semaphore() noexcept;
 
    void post() noexcept;
 
    void wait() noexcept;
 
    bool try_wait() noexcept;
};
 
class condition final: public uv_type<uv_cond_t> {
public:
    explicit condition(loop::token token, std::shared_ptr<loop> ref) noexcept;
 
    ~condition() noexcept;
 
    void signal() noexcept;
 
    void broadcast() noexcept;
 
    void wait(mutex &mtx) noexcept;
 
    bool timed_wait(mutex &mtx, uint64_t timeout) noexcept;
};
 
class barrier final: public uv_type<uv_barrier_t> {
public:
    explicit barrier(loop::token token, std::shared_ptr<loop> ref, unsigned int count) noexcept;
 
    ~barrier() noexcept;
 
    bool wait() noexcept;
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "thread.cpp"
#endif
 
#endif // UVW_THREAD_INCLUDE_H