update

Author: 7bitcoder

Include/SevenBit/DI/Details/Factories/ServiceFactory.hpp

@@ -20,13 +20,15 @@ namespace sb::di::details
       public:
         IServiceInstance::Ptr createInstance(ServiceProvider &serviceProvider, const bool inPlaceRequest) const override
         {
-            Injector injector{serviceProvider};
             if (inPlaceRequest)
             {
-                return injector.template makeUnique<InPlaceService<T>>();
+                return std::unique_ptr<InPlaceService<T>>(inject<InPlaceService<T>>(serviceProvider));
             }
-            return injector.template makeUnique<UniquePtrService<T>>();
+            return std::unique_ptr<UniquePtrService<T>>(inject<UniquePtrService<T>>(serviceProvider));
         }
+
+      private:
+        template <class S> S *inject(ServiceProvider &serviceProvider) { return CtorInjector<S>{serviceProvider}(); }
     };
 
 } // namespace sb::di::details

Include/SevenBit/DI/Details/Factories/ServiceFcnFactory.hpp

@@ -16,42 +16,29 @@ namespace sb::di::details
     template <class FactoryFcn> class ServiceFcnFactory final : public IServiceFactory
     {
         using Injector = FunctorInjector<FactoryFcn>;
+        using FunctorReturnType = decltype(Injector{nullptr, nullptr}());
+        static constexpr bool isReturnTypeOk = IsUniquePtrV<FunctorReturnType> || IsInPlaceServiceV<FunctorReturnType>;
+        static_assert(isReturnTypeOk || notSupportedType<FactoryFcn>,
+                      "Service factory return type must be std::unique_ptr<TService> or copyable/movable object");
 
         mutable FactoryFcn _factoryFunction;
 
       public:
-        using FunctorReturnType = decltype(Injector{nullptr, nullptr}());
         using ServiceType = RemoveUniquePtrT<FunctorReturnType>;
 
         explicit ServiceFcnFactory(FactoryFcn &&factoryFunction) : _factoryFunction{std::move(factoryFunction)} {}
 
         IServiceInstance::Ptr createInstance(ServiceProvider &serviceProvider, const bool inPlaceRequest) const override
         {
             Injector injector{_factoryFunction, serviceProvider};
-            if constexpr (IsUniquePtrV<FunctorReturnType>)
-            {
-                return injector.template makeUnique<UniquePtrService<ServiceType>>();
-            }
-            else if constexpr (IsInPlaceServiceV<FunctorReturnType>)
+            if constexpr (!IsUniquePtrV<FunctorReturnType>)
             {
                 if (inPlaceRequest)
                 {
                     return injector.template makeUnique<InPlaceService<ServiceType>>();
                 }
-                return injector.template makeUnique<UniquePtrService<ServiceType>>();
             }
-            else
-            {
-                badFunctor();
-                return nullptr;
-            }
-        }
-
-      private:
-        static void badFunctor()
-        {
-            static_assert(notSupportedType<FactoryFcn>,
-                          "Service factory return type must be std::unique_ptr<TService> or copyable/movable object");
+            return injector.template makeUnique<UniquePtrService<ServiceType>>();
         }
     };
 } // namespace sb::di::details

Include/SevenBit/DI/Details/Helpers/CtorInjector.hpp

@@ -41,6 +41,8 @@ namespace sb::di::details
         explicit CtorInjector(ServiceProvider &serviceProvider) : _serviceProvider(serviceProvider) {}
         explicit CtorInjector(ServiceProvider *serviceProvider) : CtorInjector(*serviceProvider) {}
 
+        T *operator()() { return makeNew(std::make_index_sequence<parametersNumber>{}); };
+
         template <class TWrapper> std::unique_ptr<TWrapper> makeUnique()
         {
             return makeUnique<TWrapper>(std::make_index_sequence<parametersNumber>{});
@@ -52,6 +54,11 @@ namespace sb::di::details
         {
             return std::make_unique<TWrapper>(ServiceExtractor<T>(&_serviceProvider, ParamNumber)...);
         }
+
+        template <std::size_t... ParamNumber> T *makeNew(std::index_sequence<ParamNumber...>)
+        {
+            return new T *{ServiceExtractor<T>(&_serviceProvider, ParamNumber)...};
+        }
     };
 
 } // namespace sb::di::details

Include/SevenBit/DI/Details/Helpers/FunctorInjector.hpp

@@ -8,12 +8,12 @@ namespace sb::di::details
 {
     template <class F> class FunctorInjector
     {
+        static_assert(IsFunctorV<F> || notSupportedType<F>, "Object is not functor/lambda");
+
         F &_functor;
         ServiceProvider &_serviceProvider;
 
       public:
-        static_assert(IsFunctorV<F> || notSupportedType<F>, "Object is not functor/lambda");
-
         FunctorInjector(F &functor, ServiceProvider &provider) : _functor(functor), _serviceProvider(provider) {}
         FunctorInjector(F *functor, ServiceProvider *provider) : FunctorInjector(*functor, *provider) {}