add inject keyed service ability

Author: 7bitcoder

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

@@ -23,4 +23,26 @@ namespace sb::di::details
             return _provider->getService<std::remove_cv_t<S>>();
         }
     };
+
+    template <class T> class KeyedServiceExtractor
+    {
+        ServiceProvider *_provider = nullptr;
+        const std::string_view _key;
+
+      public:
+        explicit KeyedServiceExtractor(ServiceProvider *provider, const std::string_view key,
+                                       std::size_t paramNumber = 0)
+            : _provider(provider), _key(key)
+        {
+        }
+
+        template <class S, class = std::enable_if_t<!IsCopyCtorV<T, S>>> operator S()
+        {
+            return ServiceGetter<std::remove_cv_t<S>>::get(*_provider, _key);
+        }
+        template <class S, class = std::enable_if_t<!IsCopyCtorV<T, S>>> operator S &() const
+        {
+            return _provider->getKeyedService<std::remove_cv_t<S>>(_key);
+        }
+    };
 } // namespace sb::di::details

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

@@ -13,43 +13,53 @@ namespace sb::di::details
 
     template <class T> struct ServiceGetter
     {
-        static auto get(ServiceProvider &provider)
+        static_assert(IsInPlaceServiceV<T> || notSupportedType<T>,
+                      "Type is not supported as function argument parameter use objects, pointers, references, "
+                      "std::unique_ptr<T>, std::vector containing pointers or std::unique_ptr<T>");
+
+        static auto get(ServiceProvider &provider) { return provider.createServiceInPlace<T>(); }
+        static auto get(ServiceProvider &provider, const std::string_view key)
         {
-            if constexpr (IsInPlaceServiceV<T>)
-            {
-                return provider.createServiceInPlace<T>();
-            }
-            else
-            {
-                static_assert(notSupportedType<T>,
-                              "Type is not supported as function argument parameter use objects, pointers, references, "
-                              "std::unique_ptr<T>, std::vector containing pointers or std::unique_ptr<T>");
-            }
+            return provider.createKeyedServiceInPlace<T>(key);
         }
     };
 
     template <class T> struct ServiceGetter<T *>
     {
         static T *get(ServiceProvider &sp) { return sp.tryGetService<T>(); }
+        static T *get(ServiceProvider &sp, const std::string_view key) { return sp.tryGetKeyedService<T>(key); }
     };
 
     template <class T> struct ServiceGetter<T &>
     {
         static T &get(ServiceProvider &sp) { return sp.getService<T>(); }
+        static T &get(ServiceProvider &sp, const std::string_view key) { return sp.getKeyedService<T>(key); }
     };
 
     template <class T> struct ServiceGetter<std::vector<T *>>
     {
         static std::vector<T *> get(ServiceProvider &sp) { return sp.getServices<T>(); }
+        static std::vector<T *> get(ServiceProvider &sp, const std::string_view key)
+        {
+            return sp.getKeyedServices<T>(key);
+        }
     };
 
     template <class T> struct ServiceGetter<std::unique_ptr<T>>
     {
         static std::unique_ptr<T> get(ServiceProvider &sp) { return sp.createService<T>(); }
+        static std::unique_ptr<T> get(ServiceProvider &sp, const std::string_view key)
+        {
+            return sp.createKeyedService<T>(key);
+        }
     };
 
     template <class T> struct ServiceGetter<std::vector<std::unique_ptr<T>>>
     {
         static std::vector<std::unique_ptr<T>> get(ServiceProvider &sp) { return sp.createServices<T>(); }
+        static std::vector<std::unique_ptr<T>> get(ServiceProvider &sp, const std::string_view key)
+        {
+            return sp.createKeyedServices<T>(key);
+        }
     };
 } // namespace sb::di::details

Include/SevenBit/DI/Utils/Injected.hpp

@@ -19,6 +19,11 @@ namespace sb::di
         [[nodiscard]] ServiceProvider &getProvider() const { return _provider; }
 
         [[nodiscard]] ServiceInlineExtractor inject() const { return ServiceInlineExtractor{getProvider()}; }
+
+        [[nodiscard]] KeyedServiceInlineExtractor inject(const std::string_view key) const
+        {
+            return KeyedServiceInlineExtractor{getProvider(), key};
+        }
     };
 
     template <class TService, class TImplementation = TService>

Include/SevenBit/DI/Utils/ServiceInlineExtractor.hpp

@@ -25,4 +25,22 @@ namespace sb::di
             return provider.getService<std::remove_cv_t<S>>();
         }
     };
+
+    struct KeyedServiceInlineExtractor
+    {
+        ServiceProvider &provider;
+        const std::string_view key;
+
+        template <class S, class = std::enable_if_t<!std::is_null_pointer_v<S> && !details::IsInitializerListV<S>>>
+        operator S()
+        {
+            return details::ServiceGetter<std::remove_cv_t<S>>::get(provider, key);
+        }
+        template <class S, class = std::enable_if_t<!std::is_const_v<S> && !std::is_null_pointer_v<S> &&
+                                                    !details::IsInitializerListV<S>>>
+        operator S &() const
+        {
+            return provider.getKeyedService<std::remove_cv_t<S>>(key);
+        }
+    };
 } // namespace sb::di