organizing metadata: erased method lambda added.

Author: neeraj31285

ReflectionTemplateLib/rtl/dispatch/CMakeLists.txt

@@ -3,16 +3,17 @@
 # Collect headers in this folder (absolute paths)
 set(LOCAL_HEADERS
 
-	"${CMAKE_CURRENT_SOURCE_DIR}/functor.h"
-	"${CMAKE_CURRENT_SOURCE_DIR}/fn_signature.h"
-	"${CMAKE_CURRENT_SOURCE_DIR}/fn_signature_rec.h"
+	"${CMAKE_CURRENT_SOURCE_DIR}/functor.h"	
 
 	"${CMAKE_CURRENT_SOURCE_DIR}/method_ptr.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/method_ptr.hpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/function_ptr.h"
-	"${CMAKE_CURRENT_SOURCE_DIR}/function_ptr.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/method_lambda.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/method_ptr_const.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/method_ptr_const.hpp"
+	
+	"${CMAKE_CURRENT_SOURCE_DIR}/function_ptr.h"
+	"${CMAKE_CURRENT_SOURCE_DIR}/function_ptr.hpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/function_lambda.h"
 
     "${CMAKE_CURRENT_SOURCE_DIR}/lambda_base.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/lambda_method.h"

ReflectionTemplateLib/rtl/dispatch/fn_signature.h renamed to ReflectionTemplateLib/rtl/dispatch/function_lambda.h

@@ -85,4 +85,54 @@ namespace rtl::dispatch
 		template<class, class ...>
 		friend struct dispatch::function_ptr;
 	};
+}
+
+
+namespace rtl::dispatch
+{
+	template<class...args_t>
+	struct function_lambda<fn_void::yes, erase::t_method, args_t...> : lambda
+	{
+		using lambda_t = std::function<void(const lambda_base&, const RObject&, traits::normal_sign_t<args_t>...)>;
+
+		const lambda_t& get_hop() const {
+			return m_lambda;
+		}
+
+	private:
+
+		void set_hop(const lambda_t& lambda) {
+			m_lambda = lambda;
+		}
+
+		lambda_t m_lambda;
+
+		template<class, class, class ...>
+		friend struct dispatch::method_ptr;
+	};
+}
+
+
+namespace rtl::dispatch
+{
+	template<class...args_t>
+	struct function_lambda<fn_void::no, erase::t_method, args_t...> : lambda
+	{
+		using lambda_t = std::function<std::any(const lambda_base&, const RObject&, traits::normal_sign_t<args_t>...)>;
+
+		const lambda_t& get_hop() const {
+			return m_lambda;
+		}
+
+	private:
+
+		void set_hop(const lambda_t& lambda) {
+			m_lambda = lambda;
+		}
+
+		lambda_t m_lambda;
+
+		template<class, class, class ...>
+		friend struct dispatch::method_ptr;
+	};
 }

ReflectionTemplateLib/rtl/dispatch/function_ptr.h

@@ -14,7 +14,7 @@
 #include <variant>
 
 #include "functor.h"
-#include "fn_signature.h"
+#include "function_lambda.h"
 
 namespace rtl::dispatch
 {

ReflectionTemplateLib/rtl/dispatch/function_ptr.hpp

@@ -12,7 +12,7 @@
 #pragma once
 
 #include "function_ptr.h"
-#include "fn_signature.h"
+#include "function_lambda.h"
 #include "aware_return.h"
 #include "aware_constructor.h"
 

ReflectionTemplateLib/rtl/dispatch/fn_signature_rec.h renamed to ReflectionTemplateLib/rtl/dispatch/method_lambda.h

@@ -11,10 +11,7 @@
 
 #pragma once
 
-#include <variant>
-
 #include "functor.h"
-#include "fn_signature_rec.h"
 
 namespace rtl::dispatch
 {
@@ -54,6 +51,7 @@ namespace rtl::dispatch
 
         static constexpr auto fn_void_v = (std::is_void_v<return_t> ? fn_void::yes : fn_void::no);
 
+        function_lambda<fn_void_v, erase::t_method, signature_t...> m_erased_method;
         method_lambda<fn_void_v, erase::t_return, record_t, signature_t...> m_erased_return;
         method_lambda<fn_void_v, erase::t_target, return_t, signature_t...> m_erased_target;
 

ReflectionTemplateLib/rtl/dispatch/method_ptr.h

@@ -12,7 +12,8 @@
 #pragma once
 
 #include "method_ptr.h"
-#include "fn_signature_rec.h"
+#include "method_lambda.h"
+#include "function_lambda.h"
 #include "aware_return_n_target.h"
 
 namespace rtl::dispatch
@@ -23,26 +24,39 @@ namespace rtl::dispatch
         if constexpr (fn_void_v == fn_void::yes) 
         {
             {
+                // erased-return-aware-target (e_return_a_target)
                 const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_return_a_target_fnv();
                 m_erased_return.set_hop(fn);
             } {
+                // erased-target-aware-return (e_target_a_return)
                 const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_target_a_return_fnv();
                 m_erased_target.set_hop(fn);
+            } {
+                // erased-return-erased-target (e_return_e_target)
+                const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_return_e_target_fnv();
+                m_erased_method.set_hop(fn);
             }
         }
         else
         {
             {
+                // erased-return-aware-target (e_return_a_target)
                 const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_return_a_target_fnr();
                 m_erased_return.set_hop(fn);
             } {
+                // erased-target-aware-return (e_target_a_return)
                 const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_target_a_return_fnr();
                 m_erased_target.set_hop(fn);
+            } {
+                // erased-return-erased-target (e_return_e_target)
+                const auto& fn = aware_return_n_target<record_t, return_t, signature_t...>::e_return_e_target_fnr();
+                m_erased_method.set_hop(fn);
             }
         }
 
-        functor::m_lambdas = std::vector<lambda*>(2);
+        functor::m_lambdas = std::vector<lambda*>(3);
         functor::m_lambdas[index::erased_return] = (&m_erased_return);
         functor::m_lambdas[index::erased_target] = (&m_erased_target);
+        functor::m_lambdas[index::erased_method] = (&m_erased_method);
     }
 }

ReflectionTemplateLib/rtl/dispatch/method_ptr.hpp

@@ -14,7 +14,7 @@
 #include <tuple>
 
 #include "functor.h"
-#include "fn_signature_rec.h"
+#include "method_lambda.h"
 
 namespace rtl::dispatch
 {

ReflectionTemplateLib/rtl/dispatch/method_ptr_const.h

@@ -11,8 +11,8 @@
 
 #pragma once
 
+#include "method_lambda.h"
 #include "method_ptr_const.h"
-#include "fn_signature_rec.h"
 #include "aware_return_n_target_const.h"
 
 namespace rtl::dispatch

ReflectionTemplateLib/rtl/dispatch/method_ptr_const.hpp

@@ -88,8 +88,6 @@ namespace rtl
         template<class record_t, class ...signature_t>
         struct lambda_method;
 
-        struct functor;
-
         struct lambda_base;
 
         struct erasure_base;
@@ -108,6 +106,8 @@ namespace rtl
 
 
         //--- These should be enough for replacement.
+        struct functor;
+
         struct lambda {};
 
         enum class fn_void {