add thread safe concept implementation

Author: 7bitcoder

Include/SevenBit/DI/Details/Core/IServiceInstanceProviderRoot.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <mutex>
+
 #include "SevenBit/DI/LibraryConfig.hpp"
 
 #include "SevenBit/DI/Details/Containers/ServiceDescriptorsMap.hpp"
@@ -16,6 +18,8 @@ namespace sb::di::details
 
         virtual ServiceInstancesCreator &getRootCreator() = 0;
 
+        virtual std::recursive_mutex *tryGetSyncMutex() = 0;
+
         virtual ~IServiceInstanceProviderRoot() = default;
     };
 } // namespace sb::di::details

Include/SevenBit/DI/Details/Core/ServiceInstanceProvider.hpp

@@ -39,6 +39,8 @@ namespace sb::di::details
 
         [[nodiscard]] IServiceInstanceProvider::Ptr createScope() const override;
 
+        std::recursive_mutex *tryGetSyncMutex() override { return _root.tryGetSyncMutex(); }
+
         const ServiceInstance &getInstance(const TypeId serviceTypeId) override
         {
             return getInstance(ServiceId{serviceTypeId});

Include/SevenBit/DI/Details/Core/ServiceInstanceProviderRoot.hpp

@@ -13,6 +13,7 @@ namespace sb::di::details
     {
         ServiceDescriptorsMap _descriptorsMap;
         ServiceInstancesMap _singletons;
+        std::unique_ptr<std::recursive_mutex> _mutex;
 
       public:
         using Ptr = std::unique_ptr<ServiceInstanceProviderRoot>;
@@ -26,6 +27,10 @@ namespace sb::di::details
               _descriptorsMap(begin, end, options.checkServiceGlobalUniqueness),
               _singletons(options.strongDestructionOrder)
         {
+            if (options.threadSafe)
+            {
+                _mutex = std::make_unique<std::recursive_mutex>();
+            }
             _descriptorsMap.seal();
         }
 
@@ -37,6 +42,8 @@ namespace sb::di::details
 
         ServiceInstancesCreator &getRootCreator() override { return getCreator(); }
 
+        std::recursive_mutex *tryGetSyncMutex() override { return _mutex.get(); }
+
       private:
         void prebuildSingletons();
     };

Include/SevenBit/DI/IServiceInstanceProvider.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string_view>
 
@@ -29,6 +30,8 @@ namespace sb::di
          */
         [[nodiscard]] virtual Ptr createScope() const = 0;
 
+        virtual std::recursive_mutex *tryGetSyncMutex() = 0;
+
         /**
          * @brief Returns service instance reference, might throw exception
          * @details If service was not registered or was registered as transient, method throws exception

Include/SevenBit/DI/Impl/ServiceCollection.hpp

@@ -11,8 +11,7 @@ namespace sb::di
 {
     INLINE ServiceProvider ServiceCollection::buildServiceProvider(ServiceProviderOptions options)
     {
-        return ServiceProvider{std::make_unique<details::ServiceInstanceProviderRoot>(begin(), end(), options),
-                               options.threadSafe};
+        return ServiceProvider{std::make_unique<details::ServiceInstanceProviderRoot>(begin(), end(), options)};
     }
 
     INLINE ServiceProvider::Ptr ServiceCollection::buildServiceProviderAsPtr(ServiceProviderOptions options)

Include/SevenBit/DI/ServiceProvider.hpp

@@ -16,21 +16,16 @@ namespace sb::di
     class ServiceProvider
     {
         IServiceInstanceProvider::Ptr _instanceProvider;
-        std::unique_ptr<std::recursive_mutex> _mutex;
 
       public:
         using Ptr = std::unique_ptr<ServiceProvider>;
 
         /**
          * @brief Constructs service provider with specified instance provider
          */
-        explicit ServiceProvider(IServiceInstanceProvider::Ptr instanceProvider, const bool threadSafe = false)
+        explicit ServiceProvider(IServiceInstanceProvider::Ptr instanceProvider)
             : _instanceProvider(std::move(instanceProvider))
         {
-            if (threadSafe)
-            {
-                _mutex = std::make_unique<std::recursive_mutex>();
-            }
             details::Require::notNull(_instanceProvider);
             getInstanceProvider().init(*this);
         }
@@ -422,7 +417,11 @@ namespace sb::di
       private:
         std::optional<std::unique_lock<std::recursive_mutex>> tryUniqueLock()
         {
-            return _mutex ? std::make_optional(std::unique_lock{*_mutex}) : std::nullopt;
+            if (const auto mutex = getInstanceProvider().tryGetSyncMutex())
+            {
+                return std::unique_lock{*mutex};
+            }
+            return std::nullopt;
         }
     };
 } // namespace sb::di

Tests/Helpers/Mocks/ServiceInstanceProviderMock.hpp

@@ -7,6 +7,7 @@
 struct ServiceInstanceProviderMock : public sb::di::IServiceInstanceProvider
 {
     MOCK_METHOD((std::unique_ptr<sb::di::IServiceInstanceProvider>), createScope, (), (const override));
+    MOCK_METHOD((std::recursive_mutex *), tryGetSyncMutex, (), (override));
     MOCK_METHOD((void), init, (sb::di::ServiceProvider &), (override));
     MOCK_METHOD((const sb::di::ServiceInstance *), tryGetInstance, (sb::di::TypeId serviceTypeId), (override));
     MOCK_METHOD((const sb::di::ServiceInstance &), getInstance, (sb::di::TypeId serviceTypeId), (override));