erase_return function cache improvement.

neeraj31285 · neeraj31285 · commit 33e48cc8126a · 2025-11-13T12:38:49.000+05:30
diff --git a/ReflectionTemplateLib/rtl/cache/cache_lambda_function.h b/ReflectionTemplateLib/rtl/cache/cache_lambda_function.h
@@ -15,6 +15,7 @@
 
 #include "lambda_function.h"
 #include "aware_return.h"
+#include "erase_return.h"
 
 namespace rtl::cache
 {
@@ -29,12 +30,21 @@ namespace rtl::cache
 
         std::pair<const dispatch::lambda_base*, const dispatch::erasure_base*> push(const dispatch::functor& p_functor) const
         {
-            m_erasure_cache.emplace_back(dispatch::aware_return<return_t, signature_t...>());
+            using aware_ret_t = dispatch::aware_return<return_t, signature_t...>;
+            using erase_ret_t = dispatch::erase_return<traits::normal_sign_t<signature_t>...>;
 
-            const dispatch::erasure_base& eb = m_erasure_cache.back();
+            m_erasure_cache.emplace_back(erase_ret_t());
+            erase_ret_t& eb = m_erasure_cache.back();
 
-            m_cache.push_back(dispatch::lambda_function<signature_t...>(p_functor, eb));
+            if constexpr (std::is_void_v<return_t>) {
+                eb.m_vhopper = aware_ret_t::get_lambda_void();
+            }
+            else {
+                eb.m_rhopper = aware_ret_t::get_lambda_any_return();
+            }
+            eb.init_base<return_t>();
 
+            m_cache.push_back(dispatch::lambda_function<signature_t...>(p_functor, eb));
             return { &m_cache.back(), &eb };
         }
 
@@ -47,7 +57,7 @@ namespace rtl::cache
 
         // No reallocation occurs; original objects stay intact
         mutable std::list<dispatch::lambda_function<signature_t...>> m_cache;
-        mutable std::list<dispatch::aware_return<return_t, signature_t...>> m_erasure_cache;
+        mutable std::list<dispatch::erase_return<traits::normal_sign_t<signature_t>...>> m_erasure_cache;
 
         lambda_function() = default;
     };
diff --git a/ReflectionTemplateLib/rtl/erasure/aware_return.h b/ReflectionTemplateLib/rtl/erasure/aware_return.h
@@ -12,31 +12,18 @@
 #pragma once
 
 #include <any>
-#include "erase_return.h"
+#include "rtl_forward_decls.h"
 
 namespace rtl::dispatch
 {
     template<class return_t, class ...signature_t>
-    struct aware_return : public erase_return<traits::normal_sign_t<signature_t>...>
+    struct aware_return
     {
-        using this_t = aware_return;
-        using base_t = erase_return<traits::normal_sign_t<signature_t>...>;
-
-        constexpr static bool is_void = (std::is_void_v<return_t>);
-
-        aware_return()
-            : base_t( is_void ? this_t::get_lambda_void() : decltype(this_t::get_lambda_void()) {},
-                     !is_void ? this_t::get_lambda_any_return() : decltype(this_t::get_lambda_any_return()) {})
-        {
-            constexpr static bool is_const_cast_safe = (!traits::is_const_v<return_t>);
-            base_t::m_return_id = detail::RObjectId::create<return_t, alloc::Stack>(is_const_cast_safe);
-        }
-
         constexpr static auto get_lambda_void() noexcept
         {
             return [](const lambda_base& lambda, traits::normal_sign_t<signature_t>&&... params)-> auto
             {
-                if constexpr (is_void)
+                if constexpr (std::is_void_v<return_t>)
                 {
                     auto fptr = lambda.template to_function<signature_t...>()
                                       .template get_functor<void>();
@@ -50,7 +37,7 @@ namespace rtl::dispatch
         {
             return [](const lambda_base& lambda, traits::normal_sign_t<signature_t>&&... params)-> auto
             {
-                if constexpr (!is_void)
+                if constexpr (!std::is_void_v<return_t>)
                 {
                     auto fptr = lambda.template to_function<signature_t...>()
                                       .template get_functor<return_t>();
@@ -70,6 +57,8 @@ namespace rtl::dispatch
                     else
                     {
                         using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                        // TODO: enable it for move-constructible objects, NRVO.
+                        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)));
                     }
                 }
diff --git a/ReflectionTemplateLib/rtl/erasure/aware_return_n_target.h b/ReflectionTemplateLib/rtl/erasure/aware_return_n_target.h
@@ -148,6 +148,8 @@ namespace rtl::dispatch
                     else
                     {
                         using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                        // TODO: enable it for move-constructible objects, NRVO.
+                        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)));
                     }
                 }
@@ -182,6 +184,8 @@ namespace rtl::dispatch
                     else
                     {
                         using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                        // TODO: enable it for move-constructible objects, NRVO.
+                        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)));
                     }
                 }
diff --git a/ReflectionTemplateLib/rtl/erasure/aware_return_n_target_const.h b/ReflectionTemplateLib/rtl/erasure/aware_return_n_target_const.h
@@ -150,6 +150,8 @@ namespace rtl::dispatch
                     else
                     {
                         using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                        // TODO: enable it for move-constructible objects, NRVO.
+                        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)));
                     }
                 }
@@ -184,6 +186,8 @@ namespace rtl::dispatch
                     else
                     {
                         using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;
+                        // TODO: enable it for move-constructible objects, NRVO.
+                        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)));
                     }
                 }
diff --git a/ReflectionTemplateLib/rtl/erasure/erase_return.h b/ReflectionTemplateLib/rtl/erasure/erase_return.h
@@ -24,20 +24,27 @@ namespace rtl::dispatch
 
         using lambda_rt = std::function<std::any(const lambda_base&, normal_sign_t...)>;
 
+        using lambda_ctor_t = std::function<Return(alloc, normal_sign_t...)>;
+
         GETTER_CREF(lambda_vt, _void_hopper, m_vhopper)
         GETTER_CREF(lambda_rt, _return_hopper, m_rhopper)
 
-    protected:
+    private:
+
+        lambda_vt m_vhopper = nullptr;
 
-        lambda_vt m_vhopper;
+        lambda_rt m_rhopper = nullptr;
 
-        lambda_rt m_rhopper;
+        lambda_ctor_t m_ctor_hopper = nullptr;
 
-        erase_return( const lambda_vt& p_void_hop,
-                      const lambda_rt& p_any_ret_hop ) noexcept
+        template<class return_t>
+        void init_base()
+        {
+            constexpr static bool is_const_cast_safe = (!traits::is_const_v<return_t>);
+            m_return_id = detail::RObjectId::create<return_t, alloc::Stack>(is_const_cast_safe);
+        }
 
-            : m_vhopper(p_void_hop)
-            , m_rhopper(p_any_ret_hop)
-        { }
+        template<class, class...>
+        friend struct cache::lambda_function;
     };
 }
diff --git a/ReflectionTemplateLib/rtl/inc/RObject.h b/ReflectionTemplateLib/rtl/inc/RObject.h
@@ -63,7 +63,7 @@ namespace rtl
         RObject(RObject&&) noexcept;
         RObject& operator=(RObject&&) noexcept;
         
-        GETTER_BOOL(Empty, (m_object == std::nullopt))
+        GETTER_BOOL(Empty, (m_object == std::nullopt || !m_object->has_value()))
         GETTER_BOOL(OnHeap, (m_objectId.m_allocatedOn == alloc::Heap))
         GETTER_BOOL(AllocatedByRtl, (m_objectId.m_allocatedOn == alloc::Heap))
         GETTER(std::size_t, TypeId, m_objectId.m_typeId)
diff --git a/ReflectionTemplateLib/rtl/inc/type_meta.hpp b/ReflectionTemplateLib/rtl/inc/type_meta.hpp
@@ -97,12 +97,12 @@ namespace rtl
 
 			auto fptr = &dispatch::aware_constructor<record_t>::allocator;
 
-			auto& functor = fc.push(fptr, traits::uid<record_t>::value, detail::member::Ctor, p_index);
+			//auto& functor = fc.push(fptr, traits::uid<record_t>::value, detail::member::Ctor, p_index);
 			//auto [lambda, elambda] = lc.push(functor);
 
 			//functor.set_lambda(lambda);
 			//functor.set_erasure(elambda);
-			return type_meta(functor);
+			//return type_meta(functor);
 		}
 		return type_meta();
 	}

Original file line number	Diff line number	Diff line change
`@@ -12,31 +12,18 @@`
`12`	`12`	`#pragma once`
`13`	`13`
`14`	`14`	`#include <any>`
`15`		`-#include "erase_return.h"`
	`15`	`+#include "rtl_forward_decls.h"`
`16`	`16`
`17`	`17`	`namespace rtl::dispatch`
`18`	`18`	`{`
`19`	`19`	`template<class return_t, class ...signature_t>`
`20`		`- struct aware_return : public erase_return<traits::normal_sign_t<signature_t>...>`
	`20`	`+ struct aware_return`
`21`	`21`	`{`
`22`		`- using this_t = aware_return;`
`23`		`- using base_t = erase_return<traits::normal_sign_t<signature_t>...>;`
`24`		`-`
`25`		`- constexpr static bool is_void = (std::is_void_v<return_t>);`
`26`		`-`
`27`		`- aware_return()`
`28`		`- : base_t( is_void ? this_t::get_lambda_void() : decltype(this_t::get_lambda_void()) {},`
`29`		`- !is_void ? this_t::get_lambda_any_return() : decltype(this_t::get_lambda_any_return()) {})`
`30`		`- {`
`31`		`- constexpr static bool is_const_cast_safe = (!traits::is_const_v<return_t>);`
`32`		`- base_t::m_return_id = detail::RObjectId::create<return_t, alloc::Stack>(is_const_cast_safe);`
`33`		`- }`
`34`		`-`
`35`	`22`	`constexpr static auto get_lambda_void() noexcept`
`36`	`23`	`{`
`37`	`24`	`return [](const lambda_base& lambda, traits::normal_sign_t<signature_t>&&... params)-> auto`
`38`	`25`	`{`
`39`		`- if constexpr (is_void)`
	`26`	`+ if constexpr (std::is_void_v<return_t>)`
`40`	`27`	`{`
`41`	`28`	`auto fptr = lambda.template to_function<signature_t...>()`
`42`	`29`	`.template get_functor<void>();`
`@@ -50,7 +37,7 @@ namespace rtl::dispatch`
`50`	`37`	`{`
`51`	`38`	`return [](const lambda_base& lambda, traits::normal_sign_t<signature_t>&&... params)-> auto`
`52`	`39`	`{`
`53`		`- if constexpr (!is_void)`
	`40`	`+ if constexpr (!std::is_void_v<return_t>)`
`54`	`41`	`{`
`55`	`42`	`auto fptr = lambda.template to_function<signature_t...>()`
`56`	`43`	`.template get_functor<return_t>();`
`@@ -70,6 +57,8 @@ namespace rtl::dispatch`
`70`	`57`	`else`
`71`	`58`	`{`
`72`	`59`	`using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;`
	`60`	`+ // TODO: enable it for move-constructible objects, NRVO.`
	`61`	`+ static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");`
`73`	`62`	`return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));`
`74`	`63`	`}`
`75`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,6 +148,8 @@ namespace rtl::dispatch`
`148`	`148`	`else`
`149`	`149`	`{`
`150`	`150`	`using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;`
	`151`	`+ // TODO: enable it for move-constructible objects, NRVO.`
	`152`	`+ static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");`
`151`	`153`	`return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));`
`152`	`154`	`}`
`153`	`155`	`}`
`@@ -182,6 +184,8 @@ namespace rtl::dispatch`
`182`	`184`	`else`
`183`	`185`	`{`
`184`	`186`	`using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;`
	`187`	`+ // TODO: enable it for move-constructible objects, NRVO.`
	`188`	`+ static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");`
`185`	`189`	`return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));`
`186`	`190`	`}`
`187`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -150,6 +150,8 @@ namespace rtl::dispatch`
`150`	`150`	`else`
`151`	`151`	`{`
`152`	`152`	`using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;`
	`153`	`+ // TODO: enable it for move-constructible objects, NRVO.`
	`154`	`+ static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");`
`153`	`155`	`return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));`
`154`	`156`	`}`
`155`	`157`	`}`
`@@ -184,6 +186,8 @@ namespace rtl::dispatch`
`184`	`186`	`else`
`185`	`187`	`{`
`186`	`188`	`using raw_ct = std::add_const_t<std::remove_reference_t<decltype(ret_v)>>;`
	`189`	`+ // TODO: enable it for move-constructible objects, NRVO.`
	`190`	`+ static_assert(std::is_copy_constructible_v<return_t>, "return-type must be copy-constructible, required by std::any");`
`187`	`191`	`return std::any(raw_ct(std::forward<decltype(ret_v)>(ret_v)));`
`188`	`192`	`}`
`189`	`193`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,12 +97,12 @@ namespace rtl`
`97`	`97`
`98`	`98`	`auto fptr = &dispatch::aware_constructor<record_t>::allocator;`
`99`	`99`
`100`		`- auto& functor = fc.push(fptr, traits::uid<record_t>::value, detail::member::Ctor, p_index);`
	`100`	`+ //auto& functor = fc.push(fptr, traits::uid<record_t>::value, detail::member::Ctor, p_index);`
`101`	`101`	`//auto [lambda, elambda] = lc.push(functor);`
`102`	`102`
`103`	`103`	`//functor.set_lambda(lambda);`
`104`	`104`	`//functor.set_erasure(elambda);`
`105`		`- return type_meta(functor);`
	`105`	`+ //return type_meta(functor);`
`106`	`106`	`}`
`107`	`107`	`return type_meta();`
`108`	`108`	`}`