export module CppUtils.Thread.SharedLocker;

import std;

import CppUtils.Thread.UniqueLocker;

export namespace CppUtils::Thread

{

/*

template<class T>

class ReadOnlyAccessor final

{

public:

inline explicit ReadOnlyAccessor(std::shared_mutex& mutex, const T& value):

m_lockGuard{mutex},

m_value{std::cref(value)}

{}

[[nodiscard]] inline auto value(this auto&& self) noexcept -> decltype(auto)

{

return self.m_value.get();

}

[[nodiscard]] inline auto operator->(this auto&& self) noexcept -> const T*

{

return std::addressof(self.value());

}

[[nodiscard]] inline auto operator*(this auto&& self) noexcept -> decltype(auto)

{

return self.value();

}

[[nodiscard]] inline auto getLockGuard() const& noexcept -> auto&

{

return m_lockGuard;

}

private:

mutable std::shared_lock m_lockGuard;

std::reference_wrapper<const T> m_value;

};

template<class T>

ReadOnlyAccessor(std::shared_mutex&, const T&) -> ReadOnlyAccessor;

/*

template<class T>

class SharedLocker final

{

public:

inline explicit SharedLocker(auto&&... args):

m_value{std::forward<decltype(args)>(args)...}

{}

[[nodiscard]] inline auto uniqueAccess() -> Accessor

{

return Accessor{m_mutex, m_value};

}

[[nodiscard]] inline auto sharedAccess() const -> ReadOnlyAccessor

{

return ReadOnlyAccessor{m_mutex, m_value};

}

private:

mutable std::shared_mutex m_mutex;

T m_value;

template<class... Lockers>

friend struct MultipleAccessor;

};

template<class T>

SharedLocker(T) -> SharedLocker;

}