function_ptr.h: using function pointer istead of lambda now.

Author: neeraj31285

ReflectionTemplateLib/rtl/detail/inc/MethodInvoker.hpp

@@ -215,6 +215,7 @@ namespace rtl::detail
             if (argsTfnMeta.is_empty() && strictArgsId == ty_meta.get_strict_args_id()) {
                 argsTfnMeta = ty_meta;
             }
+
             if (normalArgsId == ty_meta.get_normal_args_id())
             {
                 if (normalArgsId == ty_meta.get_strict_args_id()) {
@@ -279,8 +280,7 @@ namespace rtl::detail
                 }
             };
 
-            if (isReturnTvoid = ty_meta.is_void())
-            {
+            if (isReturnTvoid = ty_meta.is_void()){
                 auto fn = lambda.template operator() < dispatch::fn_void::yes > ();
                 pHopper.get_vhop().push_back(fn.get_hop());
             }
@@ -292,6 +292,7 @@ namespace rtl::detail
             pHopper.get_overloads().push_back(&ty_meta.get_functor());
             pHopper.set_init_error(error::None);
         }
+
         if (isReturnTvoid) {
             pHopper.get_rhop().clear();
         }

ReflectionTemplateLib/rtl/dispatch/aware_return.h

@@ -20,47 +20,41 @@ namespace rtl::dispatch
     template<class return_t, class ...signature_t>
     struct aware_return
     {
-        constexpr static auto get_lambda_void() noexcept
+        constexpr static void get_lambda_void(const functor& fn, traits::normal_sign_t<signature_t>&&... params) noexcept
         {
-            return [](const functor& fn, traits::normal_sign_t<signature_t>&&... params)-> auto
+            if constexpr (std::is_void_v<return_t>)
             {
-                if constexpr (std::is_void_v<return_t>)
-                {
-                    auto fptr = static_cast<const function_ptr<return_t, signature_t...>&>(fn).f_ptr();
-                    (*fptr)(std::forward<signature_t>(params)...);
-                }
-            };
+                auto fptr = static_cast<const function_ptr<return_t, signature_t...>&>(fn).f_ptr();
+                (*fptr)(std::forward<signature_t>(params)...);
+            }
         }
 
-        constexpr static auto get_lambda_any_return() noexcept
+        constexpr static std::any get_lambda_any_return(const functor& fn, traits::normal_sign_t<signature_t>&&... params) noexcept
         {
-            return [](const functor& fn, traits::normal_sign_t<signature_t>&&... params)-> auto
+            if constexpr (!std::is_void_v<return_t>)
             {
-                if constexpr (!std::is_void_v<return_t>)
-                {
-                    auto fptr = static_cast<const function_ptr<return_t, signature_t...>&>(fn).f_ptr();
-                    auto&& ret_v = (*fptr)(std::forward<signature_t>(params)...);
+                auto fptr = static_cast<const function_ptr<return_t, signature_t...>&>(fn).f_ptr();
+                auto&& ret_v = (*fptr)(std::forward<signature_t>(params)...);
 
-                    if constexpr (std::is_pointer_v<return_t>)
-                    {
-                        using raw_t = std::remove_pointer_t<return_t>;
-                        return std::any(static_cast<const raw_t*>(ret_v));
-                    }
-                    else if constexpr (std::is_reference_v<return_t>)
-                    {
-                        using raw_t = std::remove_cv_t<std::remove_reference_t<return_t>>;
-                        return std::any(static_cast<const raw_t*>(&ret_v));
-                    }
-                    else
-                    {
-                        using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
-                        // TODO: enable it for move-constructible objects.
-                        static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");
-                        return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));
-                    }
+                if constexpr (std::is_pointer_v<return_t>)
+                {
+                    using raw_t = std::remove_pointer_t<return_t>;
+                    return std::any(static_cast<const raw_t*>(ret_v));
+                }
+                else if constexpr (std::is_reference_v<return_t>)
+                {
+                    using raw_t = std::remove_cv_t<std::remove_reference_t<return_t>>;
+                    return std::any(static_cast<const raw_t*>(&ret_v));
+                }
+                else
+                {
+                    using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                    // TODO: enable it for move-constructible objects.
+                    static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");
+                    return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));
                 }
-                else return std::any();
-            };
+            }
+            else return std::any();
         }
     };
 }

ReflectionTemplateLib/rtl/dispatch/function_ptr.hpp

@@ -43,10 +43,10 @@ namespace rtl::dispatch
         func_t& fn = m_lambda.template emplace<func_t>();
 
         if constexpr (fn_void_v == fn_void::yes) {
-            fn.set_hop(aware_return<return_t, signature_t...>::get_lambda_void());
+            fn.set_hop(&aware_return<return_t, signature_t...>::get_lambda_void);
         }
         else {
-            fn.set_hop(aware_return<return_t, signature_t...>::get_lambda_any_return());
+            fn.set_hop(&aware_return<return_t, signature_t...>::get_lambda_any_return);
         }
 
         functor::m_lambdas = std::vector<lambda*>(1);