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 "loop.h"
#include "underlying_type.hpp"
 
namespace uvw {
 
namespace details {
 
enum class UVThreadCreateFlags : 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 ThreadLocalStorage;
class Once;
class Mutex;
class RWLock;
class Semaphore;
class Condition;
class Barrier;
 
class Thread final: public UnderlyingType<Thread, uv_thread_t> {
    using InternalTask = std::function<void(std::shared_ptr<void>)>;
 
    static void createCallback(void *arg);
 
public:
    using Options = details::UVThreadCreateFlags;
    using Task = InternalTask;
    using Type = uv_thread_t;
 
    explicit Thread(ConstructorAccess ca, std::shared_ptr<Loop> ref, Task t, std::shared_ptr<void> d = nullptr) noexcept;
 
    static Type self() noexcept;
 
    static bool equal(const Thread &tl, const Thread &tr) noexcept;
 
    ~Thread() noexcept;
 
    bool run() noexcept;
 
    bool run(Flags<Options> opts, std::size_t stack = {}) noexcept;
 
    bool join() noexcept;
 
private:
    std::shared_ptr<void> data;
    Task task;
};
 
class ThreadLocalStorage final: public UnderlyingType<ThreadLocalStorage, uv_key_t> {
public:
    explicit ThreadLocalStorage(ConstructorAccess ca, std::shared_ptr<Loop> ref) noexcept;
 
    ~ThreadLocalStorage() noexcept;
 
    template<typename T>
    T *get() noexcept {
        return static_cast<T *>(uv_key_get(UnderlyingType::get()));
    }
 
    template<typename T>
    void set(T *value) noexcept {
        return uv_key_set(UnderlyingType::get(), value);
    }
};
 
class Once final: public UnderlyingType<Once, uv_once_t> {
    static uv_once_t *guard() noexcept;
 
public:
    using UnderlyingType::UnderlyingType;
 
    template<typename F>
    static void once(F &&f) noexcept {
        using CallbackType = void (*)(void);
        static_assert(std::is_convertible_v<F, CallbackType>);
        CallbackType cb = f;
        uv_once(guard(), cb);
    }
};
 
class Mutex final: public UnderlyingType<Mutex, uv_mutex_t> {
    friend class Condition;
 
public:
    explicit Mutex(ConstructorAccess ca, std::shared_ptr<Loop> ref, bool recursive = false) noexcept;
 
    ~Mutex() noexcept;
 
    void lock() noexcept;
 
    bool tryLock() noexcept;
 
    void unlock() noexcept;
};
 
class RWLock final: public UnderlyingType<RWLock, uv_rwlock_t> {
public:
    explicit RWLock(ConstructorAccess ca, std::shared_ptr<Loop> ref) noexcept;
 
    ~RWLock() noexcept;
 
    void rdLock() noexcept;
 
    bool tryRdLock() noexcept;
 
    void rdUnlock() noexcept;
 
    void wrLock() noexcept;
 
    bool tryWrLock() noexcept;
 
    void wrUnlock() noexcept;
};
 
class Semaphore final: public UnderlyingType<Semaphore, uv_sem_t> {
public:
    explicit Semaphore(ConstructorAccess ca, std::shared_ptr<Loop> ref, unsigned int value) noexcept;
 
    ~Semaphore() noexcept;
 
    void post() noexcept;
 
    void wait() noexcept;
 
    bool tryWait() noexcept;
};
 
class Condition final: public UnderlyingType<Condition, uv_cond_t> {
public:
    explicit Condition(ConstructorAccess ca, std::shared_ptr<Loop> ref) noexcept;
 
    ~Condition() noexcept;
 
    void signal() noexcept;
 
    void broadcast() noexcept;
 
    void wait(Mutex &mutex) noexcept;
 
    bool timedWait(Mutex &mutex, uint64_t timeout) noexcept;
};
 
class Barrier final: public UnderlyingType<Barrier, uv_barrier_t> {
public:
    explicit Barrier(ConstructorAccess ca, 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