mutex.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_MUTEX_HPP__
#define NEFORCE_CORE_ASYNC_MUTEX_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
#ifdef NEFORCE_PLATFORM_WINDOWS
#    include "NeForce/core/config/windef.hpp"
#    include <synchapi.h>
#    ifdef max
#        undef max
#    endif
#    ifdef min
#        undef min
#    endif
#endif
#ifdef NEFORCE_PLATFORM_LINUX
#    include <pthread.h>
#endif
NEFORCE_BEGIN_NAMESPACE__


 
class mutex_base {};

class NEFORCE_API mutex : public mutex_base {
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            ::SRWLOCK;
#else
            ::pthread_mutex_t;
#endif
 
private:
    mutable native_handle_type mutex_; 
 
public:
    mutex();

    ~mutex();
 
    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;
    mutex(mutex&&) = delete;
    mutex& operator=(mutex&&) = delete;

    native_handle_type* native_handle() noexcept { return &mutex_; }

    const native_handle_type* native_handle() const noexcept { return &mutex_; }

    void lock();

    void unlock();

    bool try_lock() noexcept;
};

class NEFORCE_API recursive_mutex : public mutex_base {
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            ::CRITICAL_SECTION;
#else
            ::pthread_mutex_t;
#endif
 
private:
    mutable native_handle_type recursive_mutex_; 
 
public:
    recursive_mutex();

    ~recursive_mutex();
 
    recursive_mutex(const recursive_mutex&) = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;

    native_handle_type* native_handle() noexcept { return &recursive_mutex_; }

    const native_handle_type* native_handle() const noexcept { return &recursive_mutex_; }

    void lock();

    void unlock();

    bool try_lock() noexcept;
};
 

template <typename Mutex>
class lock {
    static_assert(is_base_of_v<mutex_base, Mutex>, "Mutex type must be derived from mutex_base");
 
public:
    using mutex_type = Mutex; 
 
private:
    mutex_type& mutex_; 
 
public:
    explicit lock(mutex_type& m) :
    mutex_(m) {
        mutex_.lock();
    }

    ~lock() { mutex_.unlock(); }
 
    lock(const lock&) = delete;
    lock& operator=(const lock&) = delete;
};
 

struct lock_defer_tag {
    constexpr lock_defer_tag() noexcept = default;
};

NEFORCE_INLINE17 constexpr lock_defer_tag lock_defer{};
 

struct lock_quiet_tag {
    constexpr lock_quiet_tag() noexcept = default;
};

NEFORCE_INLINE17 constexpr lock_quiet_tag lock_quiet{};
 

template <typename Mutex>
class unique_lock {
    static_assert(is_base_of_v<mutex_base, Mutex>, "Mutex type must be derived from mutex_base");
 
public:
    using mutex_type = Mutex; 
 
private:
    mutex_type* mutex_ = nullptr; 
    bool owns_lock_ = false;      
 
public:
    unique_lock() = default;

    explicit unique_lock(mutex_type& m) :
    mutex_(&m),
    owns_lock_(true) {
        mutex_->lock();
    }

    unique_lock(mutex_type& m, lock_defer_tag tag) noexcept :
    mutex_(&m) {}

    unique_lock(mutex_type& m, lock_quiet_tag tag) noexcept :
    mutex_(&m),
    owns_lock_(m.try_lock()) {}
 
    unique_lock(const unique_lock&) = delete;
    unique_lock& operator=(const unique_lock&) = delete;

    unique_lock(unique_lock&& other) noexcept :
    mutex_(other.mutex_),
    owns_lock_(other.owns_lock_) {
        other.mutex_ = nullptr;
        other.owns_lock_ = false;
    }

    unique_lock& operator=(unique_lock&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (owns_lock_) {
            mutex_->unlock();
        }
        mutex_ = other.mutex_;
        owns_lock_ = other.owns_lock_;
        other.mutex_ = nullptr;
        other.owns_lock_ = false;
        return *this;
    }

    ~unique_lock() {
        if (owns_lock_) {
            mutex_->unlock();
        }
    }

    NEFORCE_NODISCARD explicit operator bool() const noexcept { return owns_lock_; }

    NEFORCE_NODISCARD bool owns_lock() const noexcept { return owns_lock_; }

    NEFORCE_NODISCARD mutex_type* mutex() const noexcept { return mutex_; }

    void lock_quiet() {
        if (mutex_ == nullptr) {
            return;
        }
        if (owns_lock_) {
            return;
        }
        mutex_->lock();
        owns_lock_ = true;
    }

    void unlock_quiet() {
        if (mutex_ == nullptr) {
            return;
        }
        if (!owns_lock_) {
            return;
        }
        mutex_->unlock();
        owns_lock_ = false;
    }

    bool try_lock() noexcept {
        if (mutex_ == nullptr) {
            return false;
        }
        if (owns_lock_) {
            return true;
        }
        owns_lock_ = mutex_->try_lock();
        return owns_lock_;
    }

    mutex_type* release() noexcept {
        mutex_type* ret = mutex_;
        mutex_ = nullptr;
        owns_lock_ = false;
        return ret;
    }
};
 // Mutex
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_MUTEX_HPP__