shared_mutex.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_SHARED_MUTEX_HPP__
#define NEFORCE_CORE_ASYNC_SHARED_MUTEX_HPP__

 
#include "mutex.hpp"
NEFORCE_BEGIN_NAMESPACE__


 
class shared_mutex_base : public mutex_base {};
 

class NEFORCE_API shared_mutex : public shared_mutex_base {
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            ::SRWLOCK;
#else
            ::pthread_rwlock_t;
#endif
 
private:
    mutable native_handle_type shared_mutex_; 
 
public:
    shared_mutex();

    ~shared_mutex();
 
    shared_mutex(const shared_mutex&) = delete;
    shared_mutex& operator=(const shared_mutex&) = delete;
 
    shared_mutex(shared_mutex&&) = default;
    shared_mutex& operator=(shared_mutex&&) = default;

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

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

    void lock();

    void unlock();

    bool try_lock() noexcept;

    void lock_shared();

    void unlock_shared();

    bool try_lock_shared() noexcept;
};

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

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

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

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

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

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

    ~shared_lock() {
        if (owns_lock_) {
            mutex_->unlock_shared();
        }
    }

    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() {
        if (mutex_ == nullptr) {
            return;
        }
        if (owns_lock_) {
            return;
        }
        mutex_->lock_shared();
        owns_lock_ = true;
    }

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

    bool try_lock() noexcept {
        if (mutex_ == nullptr) {
            return false;
        }
        if (owns_lock_) {
            return true;
        }
        owns_lock_ = mutex_->try_lock_shared();
        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_SHARED_MUTEX_HPP__