SafeSharedPtr.hpp

Go to the documentation of this file.

#ifndef CPP_UTILITIES_MEMORYSAFETY_SAFESHAREDPTR_HPP
#define CPP_UTILITIES_MEMORYSAFETY_SAFESHAREDPTR_HPP
 
#include <memory>
#include <utility>
#include <type_traits>
#include "../Common.h"
#if __cplusplus >= 201703L
#include <shared_mutex>
#else
#include "RWSpinLock.hpp"
#endif
 
UTILITIES_NAMESPACE_BEGIN
 
namespace Memory {
// Forward declaration
template<typename T,
         typename mutex_t,
         typename read_lock_t,
         typename write_lock_t>
class SafeWeakPtr;
template<typename T,
         typename mutex_t,
         typename read_lock_t,
         typename write_lock_t>
class EnableSafeSharedFromThis;
 
#if __cplusplus >= 201703L
    using shared_mutex_t = std::shared_mutex;
    using shared_lock_t = std::shared_lock<shared_mutex_t>;
    using unique_lock_t = std::unique_lock<shared_mutex_t>;
#else
    using shared_mutex_t = RWSpinLock;
    using shared_lock_t = RWSpinLock::ReadHolder;
    using unique_lock_t = RWSpinLock::WriteHolder;
#endif
 
template<typename T,
         typename mutex_t = shared_mutex_t,
         typename read_lock_t = shared_lock_t,
         typename write_lock_t = unique_lock_t>
class SafeSharedPtr
{
    template<typename Y, typename M, typename R, typename W>
    friend class SafeSharedPtr;
 
public:
    template<typename Lock> class PtrHelper;
    template<typename Lock> class RefHelper;
    template<typename Lock> class ArrayHelper;
 
    using SharedMutex = mutex_t;
 
    using SharedLock = read_lock_t;
 
    using UniqueLock = write_lock_t;
 
    using element_type = typename std::remove_extent<T>::type;
 
    using weak_type = SafeWeakPtr<T, SharedMutex, SharedLock, UniqueLock>;
 
    constexpr SafeSharedPtr()
        : mutex(std::make_shared<SharedMutex>())
    {}
 
    constexpr SafeSharedPtr(std::nullptr_t p)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p)
    {}
 
    template<typename Y>
    explicit SafeSharedPtr(Y* p,
                           typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p)
    {
    }
 
    template<typename Y>
    explicit SafeSharedPtr(Y* p,
                           typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : ptr(p)
    { mutex = ptr->__safeSharedLock; }
 
    template<typename Y, typename Deleter>
    SafeSharedPtr(Y* p, Deleter d,
                  typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p, d)
    {
    }
 
    template<typename Y, typename Deleter>
    SafeSharedPtr(Y* p, Deleter d,
                  typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : ptr(p, d)
    { mutex = ptr->__safeSharedLock; }
 
    template<typename Deleter>
    SafeSharedPtr(std::nullptr_t p, Deleter d)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p, d)
    {}
 
    template<typename Y, typename Deleter, typename Alloc>
    SafeSharedPtr(Y* p, Deleter d, Alloc alloc,
                  typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p, d, alloc)
    {}
    template<typename Y, typename Deleter, typename Alloc>
    SafeSharedPtr(Y* p, Deleter d, Alloc alloc,
                  typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : ptr(p, d, alloc)
    { mutex = ptr->__safeSharedLock; }
 
    template<typename Deleter, typename Alloc>
    SafeSharedPtr(std::nullptr_t p, Deleter d, Alloc alloc)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(p, d, alloc)
    {}
 
    template<typename Y, typename U>
    SafeSharedPtr(const SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>& other, U* p) noexcept
        : mutex(other.mutex), ptr(other.ptr, p)
    {}
 
    template<typename Y>
    SafeSharedPtr(const std::shared_ptr<Y>& other, T* p,
                  typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr) noexcept
        : mutex(std::make_shared<SharedMutex>()), ptr(other, p)
    {}
    template<typename Y>
    SafeSharedPtr(const std::shared_ptr<Y>& other, T* p,
                  typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr) noexcept
        : mutex(other->__safeSharedLock), ptr(other, p)
    {
    }
 
    SafeSharedPtr(const SafeSharedPtr& other) noexcept
        : mutex(other.mutex), ptr(other.ptr)
    {}
 
    template<typename Y>
    SafeSharedPtr(const SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>& other) noexcept
        : mutex(other.mutex), ptr(other.ptr)
    {}
 
    SafeSharedPtr(SafeSharedPtr&& other) noexcept
        : mutex(std::forward<std::shared_ptr<SharedMutex>>(other.mutex)),
          ptr(std::forward<std::shared_ptr<T>>(other.ptr))
    {}
 
    template<typename Y>
    SafeSharedPtr(SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>&& other) noexcept
        : mutex(std::forward<std::shared_ptr<SharedMutex>>(other.mutex)),
          ptr(std::forward<std::shared_ptr<Y>>(other.ptr))
    {}
 
    template<typename Y>
    SafeSharedPtr(const SafeWeakPtr<Y, SharedMutex, SharedLock, UniqueLock>& other)
        : mutex(other.mutex), ptr(other.ptr)
    {}
 
    template<typename Y>
    SafeSharedPtr(const std::shared_ptr<Y>& other,
                  typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : mutex(std::make_shared<SharedMutex>()), ptr(other)
    {}
    template<typename Y>
    SafeSharedPtr(const std::shared_ptr<Y>& other,
                  typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : ptr(other)
    { mutex = ptr->__safeSharedLock; }
 
    template<typename Y>
    SafeSharedPtr(std::shared_ptr<Y>&& other,
                  typename std::enable_if<!std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : mutex(std::make_shared<SharedMutex>()),
          ptr(std::forward<std::shared_ptr<Y>>(other))
    {}
    template<typename Y>
    SafeSharedPtr(std::shared_ptr<Y>&& other,
                  typename std::enable_if<std::is_base_of<EnableSafeSharedFromThis<Y, SharedMutex, SharedLock, UniqueLock>, Y>::value>::type* = nullptr)
        : ptr(std::forward<std::shared_ptr<Y>>(other))
    { mutex = ptr->__safeSharedLock; }
 
    template<typename Y>
    SafeSharedPtr(const std::weak_ptr<Y>& other)
        : SafeSharedPtr(other.lock())
    {}
 
    ~SafeSharedPtr() = default;
 
    SafeSharedPtr& operator=(const SafeSharedPtr& other) noexcept
    {
        SafeSharedPtr(other).swap(*this);
        return *this;
    }
 
    SafeSharedPtr& operator=(SafeSharedPtr&& other) noexcept
    {
        SafeSharedPtr(std::move(other)).swap(*this);
        return *this;
    }
 
    template<typename Y>
    SafeSharedPtr& operator=(const SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>& other) noexcept
    {
        SafeSharedPtr(other).swap(*this);
        return *this;
    }
 
    template<typename Y>
    SafeSharedPtr& operator=(SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>&& other) noexcept
    {
        SafeSharedPtr(std::forward<SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>>(other)).swap(*this);
        return *this;
    }
 
    template<typename Y>
    SafeSharedPtr& operator=(const std::shared_ptr<Y>& other)
    {
        SafeSharedPtr(other).swap(*this);
        return *this;
    }
 
    template<typename Y>
    SafeSharedPtr& operator=(std::shared_ptr<Y>&& other)
    {
        SafeSharedPtr(std::forward<std::shared_ptr<Y>>(other)).swap(*this);
        return *this;
    }
 
    void reset()
    { SafeSharedPtr().swap(*this); }
 
    template<typename Y>
    void reset(Y* ptr)
    { SafeSharedPtr(ptr).swap(*this); }
 
    template<typename Y, typename Deleter>
    void reset(Y* ptr, Deleter d)
    { SafeSharedPtr(ptr, d).swap(*this); }
 
    template<typename Y, typename Deleter, typename Alloc>
    void reset(Y* ptr, Deleter d, Alloc alloc)
    { SafeSharedPtr(ptr, d, alloc).swap(*this); }
 
    void swap(SafeSharedPtr& other) noexcept
    {
        mutex.swap(other.mutex);
        ptr.swap(other.ptr);
    }
 
    element_type* get() const noexcept
    { return ptr.get(); }
 
    RefHelper<UniqueLock> operator*() noexcept
    { return RefHelper<UniqueLock>(*this); }
 
    const RefHelper<SharedLock> operator*() const noexcept
    { return RefHelper<SharedLock>(*this); }
 
    PtrHelper<UniqueLock> operator->() noexcept
    { return PtrHelper<UniqueLock>(*this); }
 
    const PtrHelper<SharedLock> operator->() const noexcept
    { return PtrHelper<SharedLock>(*this); }
 
#if __cplusplus >= 201703L
    ArrayHelper<UniqueLock> operator[](std::ptrdiff_t idx)
    { return ArrayHelper<UniqueLock>(*this, idx); }
 
    const ArrayHelper<SharedLock> operator[](std::ptrdiff_t idx) const
    { return ArrayHelper<SharedLock>(*this, idx); }
#endif
 
    long use_count() const noexcept
    { return ptr.use_count(); }
 
    explicit operator bool() const noexcept
    { return get() != nullptr; }
 
    template<typename Y, typename M, typename R, typename W>
    bool owner_before(const SafeSharedPtr<Y, M, R, W>& other) const
    { return ptr.owner_before(other.ptr); }
 
    template<typename Y, typename M, typename R, typename W>
    bool owner_before(const SafeWeakPtr<Y, M, R, W>& other) const
    { return ptr.owner_before(other.ptr); }
 
    void lock_shared() const
    { mutex->lock_shared(); }
 
    void unlock_shared() const
    { mutex->unlock_shared(); }
 
    void lock()
    { mutex->lock(); }
 
    void unlock() const
    { mutex->unlock(); }
 
    SharedLock shared_lock() const
    { return SharedLock(*mutex); }
 
    UniqueLock unique_lock() const
    { return std::move(UniqueLock(*mutex)); }
 
    template<typename Lock>
    class PtrHelper
    {
    public:
        using pointer = T*;
        using const_pointer = const T*;
        using reference = T&;
        using const_reference = const T&;
 
        explicit PtrHelper(const SafeSharedPtr& p)
            : ptr(p.get()),
              lock(*(p.mutex))
        {
        }
 
        PtrHelper(PtrHelper&& other) noexcept
            : ptr(std::move(other.ptr)),
              lock(std::move(other.lock))
        {
        }
 
        ~PtrHelper()
        {
        }
 
        PtrHelper& operator=(PtrHelper&& other)
        {
            ptr = std::move(other.ptr);
            lock = std::move(other.lock);
            return *this;
        }
 
        operator pointer()
        { return ptr; }
 
        operator const_pointer() const
        { return ptr; }
 
        pointer operator->()
        { return ptr; }
 
        const_pointer operator->() const
        { return ptr; }
 
    private:
        T* const ptr = nullptr;
        Lock lock;
 
        PtrHelper(const PtrHelper&) = delete;
        PtrHelper& operator=(const PtrHelper&) = delete;
    };
 
    template<typename Lock>
    class RefHelper
    {
    public:
        using reference = T&;
        using const_reference = const T&;
 
        explicit RefHelper(const SafeSharedPtr& p)
            : ptr(p.get()),
              lock(*(p.mutex))
        {
        }
 
        RefHelper(RefHelper&& other) noexcept
            : ptr(std::move(other.ptr)),
              lock(std::move(other.lock))
        {
        }
 
        ~RefHelper()
        {
        }
 
        RefHelper& operator=(RefHelper&& other)
        {
            ptr = std::move(other.ptr);
            lock = std::move(other.lock);
            return *this;
        }
 
        operator reference()
        { return *ptr; }
 
        operator const_reference() const
        { return *ptr; }
 
        template<typename X>
        RefHelper& operator=(const X& other)
        {
            operator reference() = other;
            return *this;
        }
 
    private:
        T* const ptr = nullptr;
        Lock lock;
 
        RefHelper(const RefHelper&) = delete;
        RefHelper& operator=(const RefHelper&) = delete;
    };
 
    #if __cplusplus >= 201703L
    template<typename Lock>
    class ArrayHelper
    {
    public:
        using element_type = std::remove_extent_t<T>;
        using pointer = element_type*;
        using const_pointer = const element_type*;
        using reference = element_type&;
        using const_reference = const element_type&;
 
        ArrayHelper(const SafeSharedPtr& p, std::ptrdiff_t idx)
            : ptr(p.get()),
              index(idx),
              lock(*(p.mutex))
        {
        }
 
        ArrayHelper(ArrayHelper&& other) noexcept
            : ptr(std::move(other.ptr)),
              index(std::move(other.index)),
              lock(std::move(other.lock))
        {
        }
 
        ~ArrayHelper()
        {
        }
 
        ArrayHelper& operator=(ArrayHelper&& other)
        {
            ptr = std::move(other.ptr);
            index = std::move(other.index);
            lock = std::move(other.lock);
            return *this;
        }
 
        operator reference()
        { return ptr[index]; }
 
        operator const_reference() const
        { return ptr[index]; }
 
        template<typename X>
        ArrayHelper& operator=(const X& other)
        {
            operator reference() = other;
            return *this;
        }
 
    private:
        element_type* const ptr = nullptr;
        std::ptrdiff_t index = 0;
        Lock lock;
 
        ArrayHelper(const ArrayHelper&) = delete;
        ArrayHelper& operator=(const ArrayHelper&) = delete;
    };
#endif
 
private:
    SafeSharedPtr(std::shared_ptr<SharedMutex> l, std::shared_ptr<T> p)
        : mutex(l), ptr(p)
    {}
 
    template<typename Y, typename M, typename R, typename W>
    friend class SafeWeakPtr;
    mutable std::shared_ptr<SharedMutex> mutex;
    std::shared_ptr<T> ptr;
};
 
template<typename T,
         typename SharedMutex = shared_mutex_t,
         typename SharedLock = shared_lock_t,
         typename UniqueLock = unique_lock_t,
         typename... Args>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> make_shared(Args&&... args)
{
    std::shared_ptr<T> p = std::make_shared<T>(std::forward<Args>(args)...);
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(p);
}
 
template<typename T,
         typename Alloc,
         typename SharedMutex = shared_mutex_t,
         typename SharedLock = shared_lock_t,
         typename UniqueLock = unique_lock_t,
         typename... Args>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> allocate_shared(const Alloc& alloc,
                                                                             Args&&... args)
{
    std::shared_ptr<T> p = std::allocate_shared<T>(alloc, std::forward<Args>(args)...);
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(p, p.get());
}
 
template<typename T,
         typename U,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> static_pointer_cast(const SafeSharedPtr<U, SharedMutex, SharedLock, UniqueLock>& r) noexcept
{
    auto p = static_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(r, p);
}
 
template<typename T,
         typename U,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> dynamic_pointer_cast(const SafeSharedPtr<U, SharedMutex, SharedLock, UniqueLock>& r) noexcept
{
    auto p = dynamic_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(r, p);
}
 
template<typename T,
         typename U,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> const_pointer_cast(const SafeSharedPtr<U, SharedMutex, SharedLock, UniqueLock>& r) noexcept
{
    auto p = const_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(r, p);
}
 
template<typename T,
         typename U,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> reinterpret_pointer_cast(const SafeSharedPtr<U, SharedMutex, SharedLock, UniqueLock>& r) noexcept
{
    auto p = reinterpret_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(r, p);
}
 
template<typename Deleter,
         typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline Deleter* get_deleter(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& p) noexcept
{ return std::get_deleter<Deleter>(p.ptr); }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator==(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                       const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return lhs.ptr == rhs.ptr; }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator!=(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                       const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return !(lhs == rhs); }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator<(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                      const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return lhs.ptr < rhs.ptr; }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator>(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                      const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return lhs.ptr > rhs.ptr; }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator<=(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                       const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return !(lhs > rhs); }
 
template<typename L,
         typename SharedMutex_L,
         typename SharedLock_L,
         typename UniqueLock_L,
         typename R,
         typename SharedMutex_R,
         typename SharedLock_R,
         typename UniqueLock_R>
inline bool operator>=(const SafeSharedPtr<L, SharedMutex_L, SharedLock_L, UniqueLock_L>& lhs,
                       const SafeSharedPtr<R, SharedMutex_R, SharedLock_R, UniqueLock_R>& rhs) noexcept
{ return !(lhs < rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator==(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                       std::nullptr_t rhs) noexcept
{ return lhs.ptr == rhs; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator==(std::nullptr_t lhs,
                       const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return lhs == rhs.ptr; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator!=(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                       std::nullptr_t rhs) noexcept
{ return !(lhs.ptr == rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator!=(std::nullptr_t lhs,
                       const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return !(lhs == rhs.ptr); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator<(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                      std::nullptr_t rhs) noexcept
{ return lhs.ptr < rhs; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator<(std::nullptr_t lhs,
                      const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return lhs < rhs.ptr; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator>(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                      std::nullptr_t rhs) noexcept
{ return lhs.ptr > rhs; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator>(std::nullptr_t lhs,
                      const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return lhs > rhs.ptr; }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator<=(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                       std::nullptr_t rhs) noexcept
{ return !(lhs > rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator<=(std::nullptr_t lhs,
                       const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return !(lhs > rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator>=(const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                       std::nullptr_t rhs) noexcept
{ return !(lhs < rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock>
inline bool operator>=(std::nullptr_t lhs,
                       const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ return !(lhs < rhs); }
 
template<typename T,
         typename SharedMutex,
         typename SharedLock,
         typename UniqueLock,
         typename OStream>
inline OStream& operator<<(OStream& os,
                           const SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& ptr)
{
    os << ptr.get();
    return os;
}
 
template<typename T,
         typename mutex_t = shared_mutex_t,
         typename read_lock_t = shared_lock_t,
         typename write_lock_t = unique_lock_t>
class SafeWeakPtr
{
public:
    using SharedMutex = mutex_t;
 
    using SharedLock = read_lock_t;
 
    using UniqueLock = write_lock_t;
 
    using element_type = typename SafeSharedPtr<T>::element_type;
 
    constexpr SafeWeakPtr() noexcept = default;
 
    template<typename Y>
    SafeWeakPtr(const SafeWeakPtr<Y, SharedMutex, SharedLock, UniqueLock>& other)
        : mutex(other.mutex), ptr(other.ptr)
    {}
 
    template<typename Y>
    SafeWeakPtr(const SafeSharedPtr<Y, SharedMutex, SharedLock, UniqueLock>& other)
        : mutex(other.mutex), ptr(other.ptr)
    {}
 
    ~SafeWeakPtr() = default;
 
    SafeWeakPtr<T>& operator=(const SafeWeakPtr<T>& other) noexcept
    {
        SafeWeakPtr<T>(other).swap(*this);
        return *this;
    }
 
    template<typename Y>
    SafeWeakPtr<T>& operator=(const SafeWeakPtr<Y, SharedMutex, SharedLock, UniqueLock>& other) noexcept
    {
        SafeWeakPtr<T>(other).swap(*this);
        return *this;
    }
 
    void reset() noexcept
    { SafeWeakPtr<T>().swap(*this); }
 
    void swap(SafeWeakPtr<T>& other) noexcept
    {
        mutex.swap(other.mutex);
        ptr.swap(other.ptr);
    }
 
    long use_count() const noexcept
    { return ptr.use_count(); }
 
    bool expired() const noexcept
    { return ptr.expired(); }
 
    SafeSharedPtr<T> lock() const noexcept
    {
        return expired() ? SafeSharedPtr<T>() : SafeSharedPtr<T>(*this);
    }
 
    template<typename Y, typename M, typename R, typename W>
    bool owner_before(const SafeWeakPtr<Y, M, R, W>& other) const
    { return ptr.owner_before(other.ptr); }
 
    template<typename Y, typename M, typename R, typename W>
    bool owner_before(const SafeSharedPtr<Y, M, R, W>& other) const
    { return ptr.owner_before(other); }
 
private:
    template<typename Y, typename M, typename R, typename W>
    friend class SafeSharedPtr;
    std::weak_ptr<SharedMutex> mutex;
    std::weak_ptr<T> ptr;
};
 
template<typename T,
         typename mutex_t = shared_mutex_t,
         typename read_lock_t = shared_lock_t,
         typename write_lock_t = unique_lock_t>
class EnableSafeSharedFromThis : public std::enable_shared_from_this<T>
{
public:
    using SharedMutex = mutex_t;
 
    using SharedLock = read_lock_t;
 
    using UniqueLock = write_lock_t;
 
    constexpr EnableSafeSharedFromThis() noexcept
        : __safeSharedLock(std::make_shared<SharedMutex>())
    {}
 
    EnableSafeSharedFromThis(const EnableSafeSharedFromThis& other) noexcept
        : std::enable_shared_from_this<T>(other),
          __safeSharedLock(other.__safeSharedLock)
    {}
 
    EnableSafeSharedFromThis(const std::enable_shared_from_this<T>& other) noexcept
        : std::enable_shared_from_this<T>(other),
          __safeSharedLock(std::make_shared<SharedMutex>())
    {}
 
    ~EnableSafeSharedFromThis() = default;
 
    EnableSafeSharedFromThis& operator=(const EnableSafeSharedFromThis& other) noexcept
    {
        static_cast<std::enable_shared_from_this<T>&>(*this)
                = static_cast<std::enable_shared_from_this<T>&>(other);
        __safeSharedLock = other.__safeSharedLock;
        return *this;
    }
 
    EnableSafeSharedFromThis<T>& operator=(const std::enable_shared_from_this<T>& other) noexcept
    {
        static_cast<std::enable_shared_from_this<T>&>(*this) = other;
        __safeSharedLock = std::make_shared<SharedMutex>();
        return *this;
    }
 
    SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock> shared_from_this()
    {
        return SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>(
                    __safeSharedLock,
                    std::enable_shared_from_this<T>::shared_from_this());
    }
 
    SafeSharedPtr<T const> shared_from_this() const
    {
        return SafeSharedPtr<T const>(__safeSharedLock,
                                      std::enable_shared_from_this<T>::shared_from_this());
    }
 
    SafeWeakPtr<T> weak_from_this()
    { return shared_from_this(); }
 
    SafeWeakPtr<T const> weak_from_this() const
    { return shared_from_this(); }
 
private:
    template<typename Y, typename M, typename R, typename W>
    friend class SafeSharedPtr;
    std::shared_ptr<typename SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>::SharedMutex> __safeSharedLock;
};
} // namespace Memory
UTILITIES_NAMESPACE_END
 
namespace std {
template<typename T,
         typename SharedMutex = Memory::shared_mutex_t,
         typename SharedLock = Memory::shared_lock_t,
         typename UniqueLock = Memory::unique_lock_t>
inline void swap(Memory::SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
                 Memory::SafeSharedPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ lhs.swap(rhs); }
template<typename T,
         typename SharedMutex = Memory::shared_mutex_t,
         typename SharedLock = Memory::shared_lock_t,
         typename UniqueLock = Memory::unique_lock_t>
void swap(Memory::SafeWeakPtr<T, SharedMutex, SharedLock, UniqueLock>& lhs,
          Memory::SafeWeakPtr<T, SharedMutex, SharedLock, UniqueLock>& rhs) noexcept
{ lhs.swap(rhs); }
} // namespace std
 
#endif  // CPP_UTILITIES_MEMORYSAFETY_SAFESHAREDPTR_HPP