organizing metadata: functor_cast in use for function.

Author: neeraj31285

RTLTestRunApp/src/FunctionalityTests/TypeErasedReflectiveCalls/BasicTypeErasedDispatch_Function.cpp

@@ -10,6 +10,8 @@
 using namespace test_utils;
 using namespace test_mirror;
 
+// TODO: test cases for functions with return type 'void'.
+
 namespace rtl_tests
 {
 	TEST(ReturnTypeErased_rtl_function, invalid_erased_return_rtl_function)

ReflectionTemplateLib/rtl/detail/inc/FunctionCaller.hpp

@@ -16,6 +16,7 @@
 #include "FunctionCaller.h"
 #include "FunctorContainer.h"
 
+#include "functor_cast.h"
 
 #include "lambda_method.h"
 #include "lambda_function.h"
@@ -109,49 +110,52 @@ namespace rtl::detail
 
 
     template<member member_kind, class ...args_t>
-    inline void HopFunction<member_kind, args_t...>::initHopper(function<rtl::Return(args_t...)>& pHopFn) const
+    inline void HopFunction<member_kind, args_t...>::initHopper(function<rtl::Return(args_t...)>& pHopper) const
     {
         bool isReturnTvoid = false;
-        for (auto& fnMeta : m_overloadsFnMeta)
+        for (auto& ty_meta : m_overloadsFnMeta)
         {
-            if (fnMeta.is_empty())
-            {
-                pHopFn.get_vhop().push_back(nullptr);
-                pHopFn.get_rhop().push_back(nullptr);
-                pHopFn.get_overloads().push_back(nullptr);
+            if (ty_meta.is_empty()) {
+                pHopper.get_vhop().push_back(nullptr);
+                pHopper.get_rhop().push_back(nullptr);
+                pHopper.get_overloads().push_back(nullptr);
                 continue;
             }
 
             if constexpr (member_kind == member::Static) {
-                if (fnMeta.get_member_kind() != member::Static) {
-                    pHopFn.set_init_error(error::InvalidNonStaticMethodCaller);
+                if (ty_meta.get_member_kind() != member::Static) {
+                    pHopper.set_init_error(error::InvalidNonStaticMethodCaller);
                     return;
                 }
             }
             else if constexpr (member_kind == member::None) {
-                if (fnMeta.get_member_kind() == member::Static) {
-                    pHopFn.set_init_error(error::InvalidStaticMethodCaller);
+                if (ty_meta.get_member_kind() == member::Static) {
+                    pHopper.set_init_error(error::InvalidStaticMethodCaller);
                     return;
                 }
             }
 
-            auto& erasedRetFn = fnMeta.get_erasure_base()
-                                      .template to_erased_return<traits::normal_sign_t<args_t>...>();
-            if (fnMeta.is_void()) {
-                isReturnTvoid = true;
-                pHopFn.get_vhop().push_back(erasedRetFn.get_void_hopper());
+            if (isReturnTvoid = ty_meta.is_void()) 
+            {
+                using fn_cast = dispatch::functor_cast<dispatch::fn_void::yes, traits::normal_sign_t<args_t>...>;
+                auto fn = fn_cast(ty_meta.get_functor()).template to_function<dispatch::erase::t_return>();
+                pHopper.get_vhop().push_back(fn.get_hop());
             }
-            else {
-                pHopFn.get_rhop().push_back(erasedRetFn.get_return_hopper());
+            else 
+            {
+                using fn_cast = dispatch::functor_cast<dispatch::fn_void::no, traits::normal_sign_t<args_t>...>;
+                auto fn = fn_cast(ty_meta.get_functor()).template to_function<dispatch::erase::t_return>();
+                pHopper.get_rhop().push_back(fn.get_hop());
             }
-            pHopFn.get_overloads().push_back(&fnMeta.get_lambda());
-            pHopFn.set_init_error(error::None);
+
+            pHopper.get_overloads().push_back(&ty_meta.get_lambda());
+            pHopper.set_init_error(error::None);
         }
         if (isReturnTvoid) {
-            pHopFn.get_rhop().clear();
+            pHopper.get_rhop().clear();
         }
         else {
-            pHopFn.get_vhop().clear();
+            pHopper.get_vhop().clear();
         }
     }
 

ReflectionTemplateLib/rtl/dispatch/functor_cast.h

@@ -19,45 +19,37 @@ namespace rtl::dispatch
     struct functor_cast
     {
         const functor& m_functor;
-        
-        template<erase erase_v>
+
         constexpr auto to_method()
         {
-            if constexpr (erase_v == erase::t_method)
-            {
-                using lambda_t = function_lambda<fn_void_v, erase::t_method, signature_t...>;
-                return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_method]);
-            }
+            using lambda_t = function_lambda<fn_void_v, erase::t_method, signature_t...>;
+            return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_method]);
         }
 
         template<erase erase_v, class known_t>
         constexpr auto to_method()
         {
+            using lambda_t = method_lambda<fn_void_v, erase_v, known_t, signature_t...>;
             if constexpr (erase_v == erase::t_return)
             {
-                using target_t = known_t;
-                using lambda_t = method_lambda<fn_void_v, erase::t_ctor, target_t, signature_t...>;
                 return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_return]);
             }
             else if constexpr (erase_v == erase::t_target)
             {
-                using return_t = known_t;
-                using lambda_t = method_lambda<fn_void_v, erase::t_return, return_t, signature_t...>;
                 return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_target]);
             }
         }
 
         template<erase erase_v>
         constexpr auto to_function()
         {
+            using lambda_t = function_lambda<fn_void_v, erase_v, signature_t...>;
             if constexpr (erase_v == erase::t_ctor)
             {
-                using lambda_t = function_lambda<fn_void_v, erase::t_ctor, signature_t...>;
                 return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_ctor]);
             }
             else if constexpr (erase_v == erase::t_return)
             {
-                using lambda_t = function_lambda<fn_void_v, erase::t_return, signature_t...>;
                 return static_cast<lambda_t&>(*m_functor.m_lambdas[functor::index::erased_return]);
             }
         }

ReflectionTemplateLib/rtl/inc/type_meta.h

@@ -45,6 +45,7 @@ namespace rtl
 
 		GETTER(detail::member, _member_kind, m_functor->get().m_member_kind)
 
+		GETTER_CREF(dispatch::functor, _functor, m_functor->get())
 		GETTER_CREF(dispatch::lambda_base, _lambda, *(m_functor->get().m_lambda))
 		GETTER_CREF(dispatch::erasure_base, _erasure_base, *(m_functor->get().m_erasure))