rtl::constructor- defined. wip.

Author: neeraj31285

RTLTestRunApp/src/CMakeLists.txt

@@ -16,6 +16,7 @@ set(LOCAL_SOURCES_0
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/PerfectForwardingTests.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/MoveConstructorTests.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/ReturnValueReflectionTest.cpp"
+	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/TypeErasedReflectiveCalls/BasicTypeErasedDispatch_Constructor.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/TypeErasedReflectiveCalls/BasicTypeErasedDispatch_Function.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/StaticTypeReflectiveCalls/StrictStaticTypeDispatch_Function.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/FunctionalityTests/TypeErasedReflectiveCalls/BasicTypeErasedDispatch_Method.cpp"

RTLTestRunApp/src/FunctionalityTests/TypeErasedReflectiveCalls/BasicTypeErasedDispatch_Constructor.cpp

@@ -0,0 +1,20 @@
+
+#include <rtl/access.h>
+#include <rtl/rtl_constructor.h>
+
+#include <gtest/gtest.h>
+
+namespace rtl_tests
+{
+	TEST(TargetTypeErased_rtl_constructor, invalid_erased_return_rtl_constructor)
+	{
+		{
+			rtl::constructor<int> ctor;
+			EXPECT_FALSE(ctor);
+
+			auto [err, robj] = ctor(rtl::alloc::Stack, 0);
+			EXPECT_EQ(err, rtl::error::InvalidCaller);
+			EXPECT_TRUE(robj.isEmpty());
+		}
+	}
+}

ReflectionTemplateLib/rtl/rtl_constructor.h

@@ -42,10 +42,64 @@ namespace rtl
 
         GETTER(rtl::error, _init_error, m_init_err)
 
-        constexpr operator bool() const noexcept;
+        constexpr operator bool() const noexcept {
+            return !(m_init_err != error::None || m_functors.empty() ||
+                     (m_functors.size() == 1 && m_functors[0] == nullptr));
+        }
+
+        constexpr bool must_bind_refs() const noexcept {
+            return (m_functors[call_by::value] == nullptr &&
+                    (m_functors.size() > call_by::ncref || m_functors[call_by::cref]->is_any_arg_ncref()));
+        }
 
         template<class ...args_t>
             requires (sizeof...(args_t) == sizeof...(signature_t))
-        constexpr Return operator()(args_t&&...params) const noexcept;
+        constexpr Return operator()(alloc p_alloc_on, args_t&&...params) const noexcept
+        {
+            if (!(*this)) [[unlikely]] {
+                return { m_init_err, RObject{} };
+            }
+
+            if (must_bind_refs()) [[unlikely]] {
+                return { error::ExplicitRefBindingRequired, RObject{} };
+            }
+
+            auto index = (m_functors[call_by::value] != nullptr ? call_by::value : call_by::cref);
+            return m_hop[index](p_alloc_on, std::forward<args_t>(params)...);
+        }
+
+        template<class ...fwd_args_t>
+        struct perfect_fwd
+        {
+            const constructor<signature_t...>& fn;
+            
+            template<class ...args_t>
+            [[nodiscard]] [[gnu::hot]] [[gnu::flatten]]
+            constexpr Return operator()(alloc p_alloc_on, args_t&&...params) const noexcept
+            {
+                if (!fn) [[unlikely]] {
+                    return { fn.m_init_err, RObject{} };
+                }
+
+                auto signature_id = traits::uid<traits::strict_sign_id_t<fwd_args_t...>>::value;
+                for (int index = 0; index < fn.m_functors.size(); index++)
+                {
+                    if (fn.m_functors[index] != nullptr &&
+                        signature_id == fn.m_functors[index]->get_strict_sign_id()) {
+                        return fn.m_hop[index](p_alloc_on, std::forward<args_t>(params)...);
+                    }
+                }
+                return { error::RefBindingMismatch, RObject{} };
+            }
+        };
+
+        template<class ...args_t>
+            requires (std::is_same_v<traits::normal_sign_id_t<args_t...>, std::tuple<signature_t...>>)
+        constexpr const perfect_fwd<args_t...> bind() const noexcept {
+            return perfect_fwd<args_t...>{ *this };
+        }
+
+        static_assert((!std::is_reference_v<signature_t> && ...),
+            "rtl::function<...>: any type cannot be specified as reference here");
     };
 }