organizing metadata: ctor-init improvements.

neeraj31285 · neeraj31285 · commit 87233b555bb4 · 2025-11-17T14:56:23.000+05:30
diff --git a/ReflectionTemplateLib/rtl/cache/cache_function_ptr.h b/ReflectionTemplateLib/rtl/cache/cache_function_ptr.h
@@ -28,18 +28,12 @@ namespace rtl::cache
             return instance_;
         }
 
-        const dispatch::functor& push_ctor(return_t(*fptr)(signature_t...), traits::uid_t p_record_uid, std::size_t lambda_index) const
-        {
-            m_cache.emplace_back(std::make_pair(function_t(fptr, p_record_uid, detail::member::DefaultCtor), lambda_index));
-            return m_cache.back().first;
-        }
-
-        template<class record_t>
+        template<detail::member mem_kind, class record_t>
         const dispatch::functor& push_ctor(traits::uid_t p_record_uid, std::size_t lambda_index) const
         {
-            m_cache.emplace_back(std::make_pair(function_t(nullptr, p_record_uid, detail::member::UserCtor), lambda_index));
+            m_cache.emplace_back(std::make_pair(function_t(nullptr, p_record_uid, mem_kind), lambda_index));
             function_t& fn = m_cache.back().first;
-            fn.template init_lambda_ctor<record_t>();
+            fn.template init_lambda<mem_kind, record_t>();
             return fn;
         }
 
diff --git a/ReflectionTemplateLib/rtl/dispatch/function_lambda.h b/ReflectionTemplateLib/rtl/dispatch/function_lambda.h
@@ -18,7 +18,8 @@ namespace rtl::dispatch
 	template<class...args_t>
 	struct function_lambda<fn_void::no, erase::t_ctor, args_t...> : lambda
 	{
-		using lambda_t = std::function<Return(alloc, traits::normal_sign_t<args_t>...)>;
+		// ditch all std::functions and use fn-pointer directly - what??? Yes!
+		using lambda_t = Return(*)(alloc, traits::normal_sign_t<args_t>&&...);
 
 		const lambda_t& get_hop() const {
 			return m_lambda;
diff --git a/ReflectionTemplateLib/rtl/dispatch/function_ptr.h b/ReflectionTemplateLib/rtl/dispatch/function_ptr.h
@@ -49,7 +49,7 @@ namespace rtl::dispatch
 
 	private:
 
-		const functor_t m_functor;
+		functor_t m_functor = nullptr;
 
 		static constexpr auto fn_void_v = (std::is_void_v<return_t> ? fn_void::yes : fn_void::no);
 
@@ -60,8 +60,8 @@ namespace rtl::dispatch
 
 		void init_lambda();
 
-		template<class record_t>
-		void init_lambda_ctor();
+		template<detail::member, class record_t>
+		void init_lambda();
 
 		template<class, class ...>
 		friend struct cache::function_ptr;
diff --git a/ReflectionTemplateLib/rtl/dispatch/function_ptr.hpp b/ReflectionTemplateLib/rtl/dispatch/function_ptr.hpp
@@ -17,34 +17,38 @@
 
 namespace rtl::dispatch
 {
-	template<class return_t, class ...signature_t>
-	template<class record_t>
-	void function_ptr<return_t, signature_t...>::init_lambda_ctor()
-	{
-		m_lambda = ctor_t();
-		ctor_t& fn = m_lambda.template emplace<ctor_t>();
-
-		fn.set_hop(aware_constructor<record_t, signature_t...>::get_allocator());
+    template<class return_t, class ...signature_t>
+    template<detail::member mem_kind, class record_t>
+    void function_ptr<return_t, signature_t...>::init_lambda()
+    {
+        m_lambda = ctor_t();
+        ctor_t& fn = m_lambda.template emplace<ctor_t>();
+        if constexpr (mem_kind == detail::member::DefaultCtor) {
+            m_functor = &aware_constructor<record_t>::default_ctor;
+		}
+        else {
+            fn.set_hop(&aware_constructor<record_t, signature_t...>::overloaded_ctor);
+		}
 
-		functor::m_lambdas = std::vector<lambda*>(1);
-		functor::m_lambdas[index::erased_ctor] = (&fn);
-	}
+        functor::m_lambdas = std::vector<lambda*>(1);
+        functor::m_lambdas[index::erased_ctor] = (&fn);
+    }
 
 
-	template<class return_t, class ...signature_t>
-	void rtl::dispatch::function_ptr<return_t, signature_t...>::init_lambda()
-	{
-		m_lambda = func_t();
-		func_t& fn = m_lambda.template emplace<func_t>();
+    template<class return_t, class ...signature_t>
+    void rtl::dispatch::function_ptr<return_t, signature_t...>::init_lambda()
+    {
+        m_lambda = func_t();
+        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());
-		}
-		else {
-			fn.set_hop(aware_return<return_t, signature_t...>::get_lambda_any_return());
-		}
+        if constexpr (fn_void_v == fn_void::yes) {
+            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());
+        }
 
-		functor::m_lambdas = std::vector<lambda*>(1);
-		functor::m_lambdas[index::erased_return] = (&fn);
-	}
+        functor::m_lambdas = std::vector<lambda*>(1);
+        functor::m_lambdas[index::erased_return] = (&fn);
+    }
 }
diff --git a/ReflectionTemplateLib/rtl/dispatch/method_ptr.h b/ReflectionTemplateLib/rtl/dispatch/method_ptr.h
@@ -49,7 +49,7 @@ namespace rtl::dispatch
 
     private:
         
-        const functor_t m_functor;
+        const functor_t m_functor = nullptr;
 
         static constexpr auto fn_void_v = (std::is_void_v<return_t> ? fn_void::yes : fn_void::no);
 
diff --git a/ReflectionTemplateLib/rtl/erasure/aware_constructor.h b/ReflectionTemplateLib/rtl/erasure/aware_constructor.h
@@ -16,40 +16,37 @@
 
 namespace rtl::dispatch
 {
-	template<class record_t, class ...signature_t>
-	struct aware_constructor
-	{
-		static auto get_allocator()
-		{
-            return [](alloc p_alloc_on, traits::normal_sign_t<signature_t>&&...params)-> Return
+    template<class record_t, class ...signature_t>
+    struct aware_constructor
+    {
+        static Return overloaded_ctor(alloc p_alloc_on, traits::normal_sign_t<signature_t>&&...params)
+        {
+            if (p_alloc_on == alloc::Stack)
             {
-                if (p_alloc_on == alloc::Stack)
-                {
-                    if constexpr (std::is_copy_constructible_v<record_t>)
-                    {
-                        return {
-                            error::None,
-                            detail::RObjectBuilder<record_t>::template build<alloc::Stack>(
-                                record_t(std::forward<signature_t>(params)...), &aware_constructor<record_t>::cloner, true
-                            )
-                        };
-                    }
-                }
-                else if (p_alloc_on == alloc::Heap)
+                if constexpr (std::is_copy_constructible_v<record_t>)
                 {
                     return {
                         error::None,
-                        detail::RObjectBuilder<record_t*>::template build<alloc::Heap>(
-                            new record_t(std::forward<signature_t>(params)...), &aware_constructor<record_t>::cloner, true
+                        detail::RObjectBuilder<record_t>::template build<alloc::Stack>(
+                            record_t(std::forward<signature_t>(params)...), &aware_constructor<record_t>::copy_ctor, true
                         )
                     };
                 }
-                return { error::EmptyRObject, RObject{} };   //dead code. compiler warning omitted.
-            };
-		}
+            }
+            else if (p_alloc_on == alloc::Heap)
+            {
+                return {
+                    error::None,
+                    detail::RObjectBuilder<record_t*>::template build<alloc::Heap>(
+                        new record_t(std::forward<signature_t>(params)...), &aware_constructor<record_t>::copy_ctor, true
+                    )
+                };
+            }
+            return { error::EmptyRObject, RObject{} };   //dead code. compiler warning omitted.
+        }
 
 
-        static Return allocator(alloc p_alloc_on)
+        static Return default_ctor(alloc p_alloc_on)
         {
             if constexpr (std::is_default_constructible_v<record_t>)
             {
@@ -61,7 +58,7 @@ namespace rtl::dispatch
                         return {
                             error::None,
                             detail::RObjectBuilder<record_t>::template build<alloc::Stack>(
-                                record_t(), &aware_constructor<record_t>::cloner, true
+                                record_t(), &aware_constructor<record_t>::copy_ctor, true
                             )
                         };
                     }
@@ -70,7 +67,7 @@ namespace rtl::dispatch
                     return {
                         error::None,
                         detail::RObjectBuilder<record_t*>::template build<alloc::Heap>(
-                            new record_t(), &aware_constructor<record_t>::cloner, true
+                            new record_t(), &aware_constructor<record_t>::copy_ctor, true
                         )
                     };
                 default:
@@ -84,7 +81,7 @@ namespace rtl::dispatch
         }
 
 
-        static Return cloner(alloc p_alloc_on, const RObject& p_other)
+        static Return copy_ctor(alloc p_alloc_on, const RObject& p_other)
         {
             if constexpr (std::is_copy_constructible_v<record_t>)
             {
@@ -95,14 +92,14 @@ namespace rtl::dispatch
                     return {
                         error::None,
                         detail::RObjectBuilder<record_t>::template build<alloc::Stack>(
-                            record_t(srcObj), &aware_constructor<record_t>::cloner, true
+                            record_t(srcObj), &aware_constructor<record_t>::copy_ctor, true
                         )
                     };
                 case alloc::Heap:
                     return {
                         error::None,
                         detail::RObjectBuilder<record_t*>::template build<alloc::Heap>(
-                            new record_t(srcObj), &aware_constructor<record_t>::cloner, true
+                            new record_t(srcObj), &aware_constructor<record_t>::copy_ctor, true
                         )
                     };
                 default:
diff --git a/ReflectionTemplateLib/rtl/erasure/erase_return.h b/ReflectionTemplateLib/rtl/erasure/erase_return.h
@@ -45,7 +45,7 @@ namespace rtl::dispatch
             if constexpr (mem_kind == detail::member::UserCtor)
             {
                 using record_t = return_t;
-                m_ctor_hopper = aware_constructor<record_t, signature_t...>::get_allocator();
+                m_ctor_hopper = &aware_constructor<record_t, signature_t...>::overloaded_ctor;
             }
             else
             {
diff --git a/ReflectionTemplateLib/rtl/inc/type_meta.hpp b/ReflectionTemplateLib/rtl/inc/type_meta.hpp
@@ -23,8 +23,6 @@
 #include "cache_lambda_method.h"
 #include "cache_lambda_function.h"
 
-#include "aware_constructor.h"
-
 namespace rtl
 {
 	template<class ...args_t>
@@ -92,13 +90,12 @@ namespace rtl
 	{
 		if constexpr (sizeof...(signature_t) == 0) {
 			auto& fc = cache::function_ptr<Return, alloc>::instance();
-			auto fptr = &dispatch::aware_constructor<record_t>::allocator;
-			auto& functor = fc.push_ctor(fptr, traits::uid<record_t>::value, p_index);
+			auto& functor = fc.template push_ctor<detail::member::DefaultCtor, record_t>(traits::uid<record_t>::value, p_index);
 			return type_meta(functor);
 		}
 		else {
 			auto& fc = cache::function_ptr<Return, signature_t...>::instance();
-			auto& functor = fc.template push_ctor<record_t>(traits::uid<record_t>::value, p_index);
+			auto& functor = fc.template push_ctor<detail::member::UserCtor, record_t>(traits::uid<record_t>::value, p_index);
 			return type_meta(functor);
 		}
 	}

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,8 @@ namespace rtl::dispatch`
`18`	`18`	`template<class...args_t>`
`19`	`19`	`struct function_lambda<fn_void::no, erase::t_ctor, args_t...> : lambda`
`20`	`20`	`{`
`21`		`- using lambda_t = std::function<Return(alloc, traits::normal_sign_t<args_t>...)>;`
	`21`	`+ // ditch all std::functions and use fn-pointer directly - what??? Yes!`
	`22`	`+ using lambda_t = Return(*)(alloc, traits::normal_sign_t<args_t>&&...);`
`22`	`23`
`23`	`24`	`const lambda_t& get_hop() const {`
`24`	`25`	`return m_lambda;`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ namespace rtl::dispatch`
`45`	`45`	`if constexpr (mem_kind == detail::member::UserCtor)`
`46`	`46`	`{`
`47`	`47`	`using record_t = return_t;`
`48`		`- m_ctor_hopper = aware_constructor<record_t, signature_t...>::get_allocator();`
	`48`	`+ m_ctor_hopper = &aware_constructor<record_t, signature_t...>::overloaded_ctor;`
`49`	`49`	`}`
`50`	`50`	`else`
`51`	`51`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,6 @@`
`23`	`23`	`#include "cache_lambda_method.h"`
`24`	`24`	`#include "cache_lambda_function.h"`
`25`	`25`
`26`		`-#include "aware_constructor.h"`
`27`		`-`
`28`	`26`	`namespace rtl`
`29`	`27`	`{`
`30`	`28`	`template<class ...args_t>`
`@@ -92,13 +90,12 @@ namespace rtl`
`92`	`90`	`{`
`93`	`91`	`if constexpr (sizeof...(signature_t) == 0) {`
`94`	`92`	`auto& fc = cache::function_ptr<Return, alloc>::instance();`
`95`		`- auto fptr = &dispatch::aware_constructor<record_t>::allocator;`
`96`		`- auto& functor = fc.push_ctor(fptr, traits::uid<record_t>::value, p_index);`
	`93`	`+ auto& functor = fc.template push_ctor<detail::member::DefaultCtor, record_t>(traits::uid<record_t>::value, p_index);`
`97`	`94`	`return type_meta(functor);`
`98`	`95`	`}`
`99`	`96`	`else {`
`100`	`97`	`auto& fc = cache::function_ptr<Return, signature_t...>::instance();`
`101`		`- auto& functor = fc.template push_ctor<record_t>(traits::uid<record_t>::value, p_index);`
	`98`	`+ auto& functor = fc.template push_ctor<detail::member::UserCtor, record_t>(traits::uid<record_t>::value, p_index);`
`102`	`99`	`return type_meta(functor);`
`103`	`100`	`}`
`104`	`101`	`}`