mutex_v2.h

#pragma once
 
namespace resumef
{
#ifndef DOXYGEN_SKIP_PROPERTY
    namespace detail
    {
        struct mutex_v2_impl;
    }
 
    inline namespace mutex_v2
    {
#endif  //DOXYGEN_SKIP_PROPERTY
 
        struct adopt_manual_unlock_t{};
 
        constexpr adopt_manual_unlock_t adopt_manual_unlock;
 
        template<class... _Mtxs>
        struct [[nodiscard]] batch_unlock_t;
 
        struct mutex_t
        {
            bool is_locked() const;
 
            struct lock_awaiter;
            struct [[nodiscard]] awaiter;
            struct [[nodiscard]] manual_awaiter;
 
            awaiter/*batch_unlock_t*/ lock() const noexcept;
            
            awaiter/*batch_unlock_t*/ operator co_await() const noexcept;
 
            manual_awaiter/*void*/ lock(adopt_manual_unlock_t manual_unlock_tag) const noexcept;
 
 
            struct [[nodiscard]] try_awaiter;
 
            try_awaiter/*bool*/ try_lock() const noexcept;
 
            struct [[nodiscard]] unlock_awaiter;
 
            unlock_awaiter/*void*/ unlock() const noexcept;
 
 
            struct [[nodiscard]] timeout_awaiter;
 
            template <class _Rep, class _Period>
            timeout_awaiter/*bool*/ try_lock_for(const std::chrono::duration<_Rep, _Period>& dt) const noexcept;
 
            template <class _Rep, class _Period>
            timeout_awaiter/*bool*/ try_lock_until(const std::chrono::time_point<_Rep, _Period>& tp) const noexcept;
 
 
            void lock(void* unique_address) const;
 
            bool try_lock(void* unique_address) const;
 
            template <class _Rep, class _Period>
            bool try_lock_for(const std::chrono::duration<_Rep, _Period>& dt, void* unique_address);
 
            template <class _Rep, class _Period>
            bool try_lock_until(const std::chrono::time_point<_Rep, _Period>& tp, void* unique_address);
 
            void unlock(void* unique_address) const;
 
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static future_t<batch_unlock_t<_Mtxs...>> lock(_Mtxs&... mtxs);
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static future_t<> lock(adopt_manual_unlock_t manual_unlock_tag, _Mtxs&... mtxs);
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static future_t<> unlock(_Mtxs&... mtxs);
 
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static batch_unlock_t<_Mtxs...> lock(void* unique_address, _Mtxs&... mtxs);
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static void lock(adopt_manual_unlock_t manual_unlock_tag, void* unique_address, _Mtxs&... mtxs);
 
            template<class... _Mtxs
#ifndef DOXYGEN_SKIP_PROPERTY
                , typename = std::enable_if_t<std::conjunction_v<std::is_same<remove_cvref_t<_Mtxs>, mutex_t>...>>
#endif  //DOXYGEN_SKIP_PROPERTY
            >
            static void unlock(void* unique_address, _Mtxs&... mtxs);
 
            mutex_t();
 
            mutex_t(std::adopt_lock_t) noexcept;
            ~mutex_t() noexcept;
 
            mutex_t(const mutex_t&) = default;
            mutex_t(mutex_t&&) = default;
            mutex_t& operator = (const mutex_t&) = default;
            mutex_t& operator = (mutex_t&&) = default;
 
#ifndef DOXYGEN_SKIP_PROPERTY
            typedef std::shared_ptr<detail::mutex_v2_impl> mutex_impl_ptr;
            typedef std::chrono::system_clock clock_type;
        private:
            struct _MutexAwaitAssembleT;
 
            template<class... _Mtxs> friend struct batch_unlock_t;
 
            mutex_impl_ptr _mutex;
#endif  //DOXYGEN_SKIP_PROPERTY
        };
    }
}