SharedLocker.mpp

export module CppUtils.Thread.SharedLocker;

import std;
export import CppUtils.Thread.UniqueLocker;

export namespace CppUtils::Thread
{
	class SharedMutex final
	{
	public:
		inline constexpr SharedMutex() noexcept
		{
			if not consteval
			{
				m_mutex.emplace();
			}
		}

		SharedMutex(const SharedMutex&) = delete;
		auto operator=(const SharedMutex&) -> SharedMutex& = delete;

		SharedMutex(SharedMutex&&) = delete;
		auto operator=(SharedMutex&&) -> SharedMutex& = delete;

		inline constexpr auto lock() -> void
		{
			if not consteval
			{
				m_mutex->lock();
			}
		}

		inline constexpr auto try_lock() -> bool
		{
			if not consteval
			{
				return m_mutex->try_lock();
			}
			return true;
		}

		inline constexpr auto unlock() -> void
		{
			if not consteval
			{
				m_mutex->unlock();
			}
		}

		inline constexpr auto lock_shared() -> void
		{
			if not consteval
			{
				m_mutex->lock_shared();
			}
		}

		inline constexpr auto try_lock_shared() -> bool
		{
			if not consteval
			{
				return m_mutex->try_lock_shared();
			}
			return true;
		}

		inline constexpr auto unlock_shared() -> void
		{
			if not consteval
			{
				m_mutex->unlock_shared();
			}
		}

	private:
		std::optional<std::shared_mutex> m_mutex;
	};

	/**
	 * @brief RAII accessor providing concurrent read-only access to a protected value.
	 *
	 * Uses std::shared_lock internally to allow multiple readers simultaneously.
	 *
	 * @see https://morgancaron.github.io/CppUtils/fr/guides/lockers/ (Guide de synchronisation RAII)
	 * @see https://morgancaron.github.io/CppUtils/en/guides/lockers/ (RAII synchronization guide)
	 *
	 * @tparam T Type of the value being accessed.
	 * @tparam Mutex Mutex type used for locking (defaults to SharedMutex).
	 */
	template<class T, class Mutex = SharedMutex>
	class ReadOnlyAccessor final
	{
	public:
		/**
		 * @brief Constructs a read-only accessor by acquiring a shared lock on the mutex.
		 * @param mutex Shared mutex to lock.
		 * @param value Reference to the value to read.
		 */
		inline explicit constexpr ReadOnlyAccessor(Mutex& mutex, const T& value):
			m_value{std::cref(value)}
		{
			if not consteval
			{
				m_lockGuard.emplace(mutex);
			}
		}

		/// @brief Returns a const reference to the protected value.
		[[nodiscard]] inline constexpr auto value(this auto&& self [[clang::lifetimebound, msvc::lifetimebound]]) noexcept -> decltype(auto)
		{
			return self.m_value.get();
		}

		/// @brief Accesses const member functions or fields of the protected value.
		[[nodiscard]] inline constexpr auto operator->(this auto&& self [[clang::lifetimebound, msvc::lifetimebound]]) noexcept -> const T*
		{
			return std::addressof(self.value());
		}

		/// @brief Dereferences to obtain the protected const value (equivalent to calling value()).
		[[nodiscard]] inline constexpr auto operator*(this auto&& self [[clang::lifetimebound, msvc::lifetimebound]]) noexcept -> decltype(auto)
		{
			return self.value();
		}

		/**
		 * @brief Returns a reference to the underlying @c std::shared_lock guard.
		 *
		 * Provides direct access to the lock guard, allowing it to be used with
		 * synchronization primitives requiring a @c std::shared_lock (such as @c std::condition_variable_any::wait).
		 *
		 * When used with @c std::condition_variable_any::wait, the wait function atomically releases the shared mutex while
		 * placing the thread to sleep, and re-acquires the shared lock upon waking before returning once the predicate evaluates to true:
		 * @code
		 * auto reader = cache.sharedAccess();
		 * conditionAny.wait(reader.getLockGuard(), [&] {
		 *     return reader->contains("ready");
		 * });
		 * @endcode
		 *
		 * @return Reference to the internal @c std::shared_lock<Mutex>.
		 */
		[[nodiscard]] inline constexpr auto getLockGuard(this auto&& self [[clang::lifetimebound, msvc::lifetimebound]]) noexcept -> auto&
		{
			return self.m_lockGuard.value();
		}

	private:
		mutable std::optional<std::shared_lock<Mutex>> m_lockGuard;
		std::reference_wrapper<const T> m_value;
	};

	template<class Mutex, class T>
	ReadOnlyAccessor(Mutex&, const T&) -> ReadOnlyAccessor<T, Mutex>;

	/**
	 * @brief Monitor Object wrapper providing shared read / exclusive write synchronization.
	 *
	 * Encapsulates a resource with a std::shared_mutex, allowing either multiple concurrent
	 * read-only accessors (via sharedAccess()) or a single exclusive read-write accessor
	 * (via uniqueAccess()).
	 *
	 * @see https://morgancaron.github.io/CppUtils/fr/guides/lockers/ (Guide de synchronisation RAII)
	 * @see https://morgancaron.github.io/CppUtils/en/guides/lockers/ (RAII synchronization guide)
	 *
	 * @tparam T Type of the protected resource.
	 */
	template<class T>
	class SharedLocker final
	{
	public:
		using UniqueAccessor = Accessor<T, SharedMutex>;
		using SharedAccessor = ReadOnlyAccessor<T, SharedMutex>;

		inline constexpr SharedLocker() requires std::default_initializable<T> = default;

		/**
		 * @brief Constructs the protected resource in place.
		 * @param first First argument forwarded to the resource constructor.
		 * @param rest Rest of arguments forwarded to the resource constructor.
		 */
		inline explicit constexpr SharedLocker(auto&& first, auto&&... rest):
			m_value{std::forward<decltype(first)>(first), std::forward<decltype(rest)>(rest)...}
		{}

		SharedLocker(const SharedLocker&) = delete;
		auto operator=(const SharedLocker&) -> SharedLocker& = delete;

		/// @brief Move constructor. Acquires lock on the source locker before moving its value.
		inline constexpr SharedLocker(SharedLocker&& other) noexcept(std::is_nothrow_move_constructible_v<T>):
			m_value{std::move(other.uniqueAccess().value())}
		{}

		/// @brief Move assignment. Acquires scoped lock on both mutexes before moving the value.
		inline constexpr auto operator=(SharedLocker&& other) noexcept(std::is_nothrow_move_assignable_v<T>) -> SharedLocker&
		{
			if (this != std::addressof(other))
			{
				if not consteval
				{
					auto guard = std::scoped_lock{m_mutex, other.m_mutex};
					m_value = std::move(other.m_value);
				}
				else
				{
					m_value = std::move(other.m_value);
				}
			}
			return *this;
		}

		/**
		 * @brief Acquires exclusive read/write access.
		 * @return UniqueAccessor holding a unique lock.
		 */
		[[nodiscard]] inline constexpr auto uniqueAccess() -> UniqueAccessor
		{
			return Accessor{m_mutex, m_value};
		}

		/**
		 * @brief Acquires shared read-only access.
		 * @return SharedAccessor holding a shared lock.
		 */
		[[nodiscard]] inline constexpr auto sharedAccess() const -> SharedAccessor
		{
			return ReadOnlyAccessor{m_mutex, m_value};
		}

	private:
		mutable SharedMutex m_mutex;
		T m_value{};

		template<class... Lockers>
		friend struct MultipleAccessor;
	};

	template<class T>
	SharedLocker(T) -> SharedLocker<T>;
}