Thread/SafeShared

Author: MorganCaron

modules/Random/Random.mpp

@@ -4,12 +4,12 @@ import std;
 
 export namespace CppUtils::Random
 {
-	template<std::integral Int = std::size_t>
-	inline auto getRandomNumberInInterval(Int min, Int max) -> Int
+	template<std::integral Integer>
+	inline auto getRandomNumberInInterval(Integer min, Integer max) -> Integer
 	{
 		static auto randomDevice = std::random_device{};
 		static auto engine = std::mt19937{randomDevice()};
-		static auto distribution = std::uniform_int_distribution<Int>{min, max};
+		static auto distribution = std::uniform_int_distribution<Integer>{min, max};
 		auto randomNumber = distribution(engine);
 		return randomNumber;
 	}

modules/Thread/SafeShared.mpp

@@ -0,0 +1,29 @@
+export module CppUtils.Thread.SafeShared;
+
+import std;
+import CppUtils.Thread.SharedLocker;
+
+export namespace CppUtils::Thread
+{
+	template<class T>
+	class SafeShared final
+	{
+	public:
+		inline explicit SafeShared(auto&&... args):
+			m_locker{std::make_shared<SharedLocker<T>>(std::forward<decltype(args)>(args)...)}
+		{}
+
+		[[nodiscard]] inline auto uniqueAccess() -> auto
+		{
+			return m_locker->uniqueAccess();
+		}
+
+		[[nodiscard]] inline auto sharedAccess() const -> auto
+		{
+			return m_locker->sharedAccess();
+		}
+
+	private:
+		std::shared_ptr<SharedLocker<T>> m_locker;
+	};
+}

modules/Thread/SharedLocker.mpp

@@ -14,17 +14,17 @@ export namespace CppUtils::Thread
 			m_value{std::cref(value)}
 		{}
 
-		[[nodiscard]] inline auto value() const noexcept -> decltype(auto)
+		[[nodiscard]] inline auto value() const& noexcept -> decltype(auto)
 		{
 			return m_value.get();
 		}
 
-		[[nodiscard]] inline auto operator->() const noexcept -> decltype(auto)
+		[[nodiscard]] inline auto operator->() const& noexcept -> decltype(auto)
 		{
 			return &value();
 		}
 
-		[[nodiscard]] inline auto getLockGuard() const noexcept -> auto&
+		[[nodiscard]] inline auto getLockGuard() const& noexcept -> auto&
 		{
 			return m_lockGuard;
 		}

modules/Thread/Thread.mpp

@@ -2,6 +2,7 @@ export module CppUtils.Thread;
 
 export import CppUtils.Thread.AsyncIStreamListener;
 export import CppUtils.Thread.Event;
+export import CppUtils.Thread.SafeShared;
 export import CppUtils.Thread.SharedLocker;
 export import CppUtils.Thread.SharedPtr;
 export import CppUtils.Thread.ThreadLoop;

modules/Thread/UniqueLocker.mpp

@@ -13,17 +13,17 @@ export namespace CppUtils::Thread
 			m_value{std::ref(value)}
 		{}
 
-		[[nodiscard]] inline auto value() noexcept -> decltype(auto)
+		[[nodiscard]] inline auto value() & noexcept -> decltype(auto)
 		{
 			return m_value.get();
 		}
 
-		[[nodiscard]] inline auto operator->() noexcept -> decltype(auto)
+		[[nodiscard]] inline auto operator->() & noexcept -> decltype(auto)
 		{
 			return &value();
 		}
 
-		[[nodiscard]] inline auto getLockGuard() noexcept -> auto&
+		[[nodiscard]] inline auto getLockGuard() & noexcept -> auto&
 		{
 			return m_lockGuard;
 		}

tests/Thread/SafeShared.mpp

@@ -0,0 +1,38 @@
+export module CppUtils.UnitTests.Thread.SafeShared;
+
+import CppUtils;
+
+export namespace CppUtils::UnitTest::Thread::SafeShared
+{
+	inline auto _ = CppUtils::UnitTest::TestSuite{"Thread/SafeShared", {"UnitTest", "Thread/SharedLocker"}, [](auto& suite) {
+		suite.addTest("Unique access", [&] {
+			auto safeSharedString0 = CppUtils::Thread::SafeShared<std::string>{"Foo"};
+			auto safeSharedString1 = safeSharedString0;
+			{
+				auto accessor = safeSharedString0.uniqueAccess();
+				suite.expect(accessor.value() == "Foo");
+				accessor.value() = "Bar";
+				suite.expect(accessor.value() == "Bar");
+			}
+			{
+				auto accessor = safeSharedString1.uniqueAccess();
+				suite.expect(accessor.value() == "Bar");
+			}
+		});
+
+		suite.addTest("Shared access", [&] {
+			auto safeSharedString0 = CppUtils::Thread::SafeShared<std::string>{"Foo"};
+			auto safeSharedString1 = safeSharedString0;
+			{
+				auto accessor0 = safeSharedString0.sharedAccess();
+				auto accessor1 = safeSharedString0.sharedAccess();
+				auto accessor2 = safeSharedString1.sharedAccess();
+				auto accessor3 = safeSharedString1.sharedAccess();
+				suite.expect(accessor0.value() == "Foo");
+				suite.expect(accessor1.value() == "Foo");
+				suite.expect(accessor2.value() == "Foo");
+				suite.expect(accessor3.value() == "Foo");
+			}
+		});
+	}};
+}

tests/Thread/SharedLocker.mpp

@@ -4,7 +4,7 @@ import CppUtils;
 
 export namespace CppUtils::UnitTest::Thread::SharedLocker
 {
-	inline auto _ = CppUtils::UnitTest::TestSuite{"Thread/SharedLocker", {"UnitTest"}, [](auto& suite) {
+	inline auto _ = CppUtils::UnitTest::TestSuite{"Thread/SharedLocker", {"UnitTest", "Thread/UniqueLocker"}, [](auto& suite) {
 		suite.addTest("Unique access", [&] {
 			auto lockedString = CppUtils::Thread::SharedLocker<std::string>{"Foo"};
 			{