Resolve const

Hypodermic.Tests/CMakeLists.txt

@@ -28,6 +28,7 @@ set(HypodermicTests_sources
     ProvidedInstanceFactoryRegistrationTests.cpp
     ProvidedInstanceRegistrationTests.cpp
     RegistrationTests.cpp
+    ResolveConstPtrTests.cpp
     RuntimeRegistrationTests.cpp
     UseIfNoneTests.cpp
 )

Hypodermic.Tests/ResolveConstPtrTests.cpp

@@ -0,0 +1,121 @@
+#include "stdafx.h"
+
+#include "Hypodermic/ContainerBuilder.h"
+
+
+namespace Hypodermic
+{
+namespace Testing
+{
+namespace
+{
+
+    class Foo
+    {
+    public:
+        int value() const
+        {
+            return 42;
+        }
+    };
+
+    class Bar
+    {
+    public:
+        explicit Bar(std::shared_ptr<Foo> foo) noexcept : _foo(std::move(foo))
+        { }
+
+        const std::shared_ptr<Foo>& foo() const noexcept
+        {
+            return _foo;
+        }
+
+    private:
+        std::shared_ptr<Foo> _foo;
+    };
+
+    class Baz
+    {
+    public:
+        explicit Baz(std::shared_ptr<const Foo> foo) noexcept : _foo(std::move(foo))
+        { }
+
+        const std::shared_ptr<const Foo>& foo() const noexcept
+        {
+            return _foo;
+        }
+
+    private:
+        std::shared_ptr<const Foo> _foo;
+    };
+
+} // namespace
+
+    BOOST_AUTO_TEST_SUITE(ResolveConstPtrTests)
+
+    BOOST_AUTO_TEST_CASE(should_resolve_non_const_ptr)
+    {
+        // Arrange
+        ContainerBuilder builder;
+        builder.registerType<Foo>();
+        auto container = builder.build();
+
+        // Act
+        const auto foo = container->resolve<Foo>();
+        auto value = foo->value();
+
+        // Assert
+        BOOST_CHECK_EQUAL(value, 42);
+    }
+
+    BOOST_AUTO_TEST_CASE(should_resolve_const_ptr)
+    {
+        // Arrange
+        ContainerBuilder builder;
+        builder.registerType<Foo>();
+        auto container = builder.build();
+
+        // Act
+        const auto cfoo = container->resolve<const Foo>();
+        auto value = cfoo->value();
+
+        // Assert
+        BOOST_CHECK_EQUAL(value, 42);
+    }
+
+    BOOST_AUTO_TEST_CASE(should_resolve_non_const_ptr_argument)
+    {
+        // Arrange
+        ContainerBuilder builder;
+        builder.registerType<Foo>();
+        builder.registerType<Bar>();
+        auto container = builder.build();
+
+        // Act
+        const auto bar = container->resolve<Bar>();
+        auto value = bar->foo()->value();
+
+        // Assert
+        BOOST_CHECK_EQUAL(value, 42);
+    }
+
+    BOOST_AUTO_TEST_CASE(should_resolve_const_ptr_argument)
+    {
+        // Arrange
+        ContainerBuilder builder;
+        builder.registerType<Foo>();
+        builder.registerType<Baz>();
+        auto container = builder.build();
+
+        // Act
+        const auto baz = container->resolve<Baz>();
+        auto value = baz->foo()->value();
+
+        // Assert
+        BOOST_CHECK_EQUAL(value, 42);
+    }
+
+    BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace Testing
+} // namespace Hypodermic

Hypodermic/ComponentContext.h

@@ -156,11 +156,12 @@ namespace Hypodermic
         template <class T>
         bool tryToRegisterType(IRegistrationScope& scope, std::true_type /* T has autowireable constructor */)
         {
-            auto&& factory = Traits::ConstructorDescriptor< T >::describe();
+            using MutableT = std::remove_const_t<T>;
+            auto&& factory = Traits::ConstructorDescriptor< MutableT >::describe();
 
             scope.addRegistration(m_runtimeRegistrationBuilder->build
             (
-                Utils::getMetaTypeInfo< T >(),
+                Utils::getMetaTypeInfo< MutableT >(),
                 [factory](const IRegistration& r, IResolutionContext& c) { return std::static_pointer_cast< void >(factory(r, c)); }
             ));