introducing rtl::detail::lambda_table

Author: panda-ptr

ReflectionTemplateLib/access/inc/Function.h

@@ -67,6 +67,8 @@ namespace rtl {
 
         const std::size_t hasSignatureId(const std::size_t pSignatureId) const;
 
+        const detail::FunctorId* hasFunctorId(const std::size_t pSignatureId) const;
+
         GETTER(detail::methodQ, Qualifier, m_qualifier);
 
         GETTER_REF(std::vector<detail::FunctorId>, FunctorIds, m_functorIds)

ReflectionTemplateLib/access/inc/Function.hpp

@@ -63,4 +63,16 @@ namespace rtl
         }
         return rtl::index_none;
     }
+
+
+    FORCE_INLINE const detail::FunctorId* Function::hasFunctorId(const std::size_t pSignatureId) const
+    {
+        //simple linear-search, efficient for small set of elements.
+        for (const auto& functorId : m_functorIds) {
+            if (functorId.getSignatureId() == pSignatureId) [[likely]] {
+                return &functorId;
+            }
+        }
+        return nullptr;
+    }
 }

ReflectionTemplateLib/detail/inc/CallReflector.h

@@ -14,6 +14,7 @@
 #include <optional>
 #include "RObject.h"
 #include "Constants.h"
+#include "FunctorId.h"
 
 namespace rtl::detail {
 
@@ -30,10 +31,14 @@ namespace rtl::detail {
         * gets the lambda vector from '_derivedType' and calls the lambda at given index with '_args'.
         * this 'forwardCall' is for calling lambda containing non-member-function and static-member-function functors.
     */  template<class ..._params>
-        FORCE_INLINE static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)
+        FORCE_INLINE static Return forwardCall(const detail::FunctorId& pFunctorId, _params&&..._args)
         {
+            // static_cast to derived type, gaurateed safe by design.
+            //auto lambdaTable = static_cast<_derivedType::lambda_t*>(pFunctorId.m_lambdaTable);
+            //return lambdaTable->get()[pFunctorId.m_index](std::forward<_params>(_args)...);
+
             //'getFunctors()' must be implemented by _derivedType (FunctorContainer).
-            return _derivedType::getFunctors()[pFunctorIndex](std::forward<_params>(_args)...);
+            return _derivedType::getFunctors()[pFunctorId.m_index](std::forward<_params>(_args)...);
         }
 
 

ReflectionTemplateLib/detail/inc/FunctionCaller.hpp

@@ -26,9 +26,13 @@ namespace rtl::detail
                                              FunctorContainer<std::remove_reference_t<_args>...>,
                                              FunctorContainer<_signature...>>;
 
-        std::size_t index = m_function->hasSignatureId(Container::getContainerId());
-        if (index != rtl::index_none) [[likely]] {
-            return Container::template forwardCall<_args...>(index, std::forward<_args>(params)...);
+        //auto containerId = Container::getContainerId();
+        //const detail::FunctorId* functorId = m_function->hasFunctorId(containerId);
+        //return { error::None, RObject{} };
+
+        const detail::FunctorId* functorId = m_function->hasFunctorId(Container::getContainerId());
+        if (functorId != nullptr) [[likely]] {
+            return Container::template forwardCall<_args...>(*functorId, std::forward<_args>(params)...);
         }
         return { error::SignatureMismatch, RObject{} };
     }

ReflectionTemplateLib/detail/inc/FunctorContainer.h

@@ -15,6 +15,7 @@
 #include <vector>
 #include <functional>
 
+#include "LambdaTable.h"
 #include "Constants.h"
 #include "CallReflector.h"
 #include "SetupFunction.h"
@@ -27,10 +28,10 @@ namespace rtl {
         //forward decl
         class ReflectionBuilder;
 
-    /*  @class: FunctorContainer
-        @param: '_signature...' (combination of any types)
-        * container class for holding lambda's wrapping functor, constructor calls of same signatures.
-        * maintains a std::vector<std::function> with static lifetime.
+        /*  @class: FunctorContainer
+            @param: '_signature...' (combination of any types)
+            * container class for holding lambda's wrapping functor, constructor calls of same signatures.
+            * maintains a std::vector<std::function> with static lifetime.
     */  template<class ..._signature>
         class FunctorContainer : public SetupFunction<FunctorContainer<_signature...>>,
                                  public SetupConstructor<FunctorContainer<_signature...>>,
@@ -39,6 +40,8 @@ namespace rtl {
             using FunctionLambda = std::function < Return(_signature...) >;
         public:
 
+            using lambda_t = detail::functors<_signature...>;
+
             //every FunctorContainer<...> will have a unique-id.
             FORCE_INLINE static std::size_t getContainerId() {
                 static const std::size_t containerId = generate_unique_id();
@@ -67,26 +70,37 @@ namespace rtl {
                 return  functorTable;
             }
 
+            static lambda_t& lambdaCache()
+            {
+                static lambda_t functorsCache;
+                return functorsCache;
+            }
+
         /*  @method: pushBack
             @params: pFunctor (lambda containing functor or constructor call)
-                     pGetIndex (lambda providing index if the functor is already registered)
-                     pUpdate (lambda updating the already registered functors/ctor/d'tor set)
+                        pGetIndex (lambda providing index if the functor is already registered)
+                        pUpdate (lambda updating the already registered functors/ctor/d'tor set)
             @return: index of newly added or already existing lambda in vector 'm_functors'.
-        */  static std::size_t pushBack(const FunctionLambda& pFunctor,
-                                        std::function<const std::size_t()> pGetIndex,
-                                        std::function<void(const std::size_t&)> pUpdate)
+        */  static std::pair<std::size_t, detail::lambda_table*> pushBack(const FunctionLambda& pFunctor,
+                                                                          std::function<const std::size_t()> pGetIndex,
+                                                                          std::function<void(const std::size_t&)> pUpdate)
             {
                 //critical section, thread safe.
                 static std::mutex mtx;
                 std::lock_guard<std::mutex> lock(mtx);
 
                 std::size_t index = pGetIndex();
-                if (index == rtl::index_none) {
-                    index = getFunctorTable().size();
-                    pUpdate(index);
+                if (index == rtl::index_none) 
+                {
+                    index = lambdaCache().get().size();
+
+                    lambdaCache().pushBack(pFunctor);
+
                     getFunctorTable().push_back(pFunctor);
+
+                    pUpdate(index);
                 }
-                return index;
+                return { index, &lambdaCache() };
             }
 
             //friends :)

ReflectionTemplateLib/detail/inc/FunctorId.h

@@ -14,64 +14,65 @@
 #include "TypeId.h"
 #include "Constants.h"
 
-namespace rtl
+namespace rtl::detail
 {
-    namespace detail
+    class lambda_table;
+
+/*  @class: FunctorId
+    * 'FunctorId' object is generated for every functor (member/non-member function pointer) registered.
+    * acts as a hash-key to lookup a particular functor in the functor-table.
+    * first, using 'm_containerId', the functor-table container is found.
+    * once table is found, the functor is accessed at index 'm_index', (never fails, noexcept)
+    * 'FunctorId' generated for a each functor is unique, even for overloaded functions.
+    * multiple registartion of same functor will generate same duplicate 'FunctorId'.
+*/  struct FunctorId
     {
-    /*  @class: FunctorId
-        * 'FunctorId' object is generated for every functor (member/non-member function pointer) registered.
-        * acts as a hash-key to lookup a particular functor in the functor-table.
-        * first, using 'm_containerId', the functor-table container is found.
-        * once table is found, the functor is accessed at index 'm_index', (never fails, noexcept)
-        * 'FunctorId' generated for a each functor is unique, even for overloaded functions.
-        * multiple registartion of same functor will generate same duplicate 'FunctorId'.
-    */  struct FunctorId
-        {
-            //index of the functor in the functor-table.
-            std::size_t m_index;
+        //index of the functor in the functor-table.
+        std::size_t m_index;
 
-            //return type-id of the functor registered.
-            std::size_t m_returnId;
+        //return type-id of the functor registered.
+        std::size_t m_returnId;
 
-            //if functor is a member-function, type id of class/struct it belongs to.
-            std::size_t m_recordId;
+        //if functor is a member-function, type id of class/struct it belongs to.
+        std::size_t m_recordId;
 
-            //containerId of the functor-table.
-            std::size_t m_containerId;
+        //containerId of the functor-table.
+        std::size_t m_containerId;
 
-            //signature of functor as string. platform dependent, may not be very much readable format.
-            std::string m_signature;
+        //signature of functor as string. platform dependent, may not be very much readable format.
+        std::string m_signature;
 
-            GETTER(std::size_t, Index, m_index)
-            GETTER(std::size_t, ReturnId, m_returnId);
-            GETTER(std::size_t, RecordId, m_recordId);
-            GETTER(std::size_t, SignatureId, m_containerId)
-            GETTER(std::string, SignatureStr, m_signature)
+        lambda_table* m_lambdaTable = nullptr;
 
-        /*  @method: getHashCode()
-            @return: std::size_t (a unique hash-code for a functor)
-            * 'm_containerId' will be same for functors(non-member) with same signatures.
-            * for member functions, a functor will have three atrributes
-                - signature
-                - whether it is const or non-const
-                - class/struct type
-              'm_containerId' will be same for functors with same above attributes.
-            * every functor will have a distinct index in the functor-wrapped-lambda-table.
-            * so, combination of m_containerId & m_index is unique for every functor.
-        */  std::size_t getHashCode() const
-            {
-                return std::stoull(std::to_string(m_containerId) +
-                                   std::to_string(m_index) +
-                                   std::to_string(m_recordId) +
-                                   std::to_string(m_returnId));
-            }
+        GETTER(std::size_t, Index, m_index)
+        GETTER(std::size_t, ReturnId, m_returnId);
+        GETTER(std::size_t, RecordId, m_recordId);
+        GETTER(std::size_t, SignatureId, m_containerId)
+        GETTER(std::string, SignatureStr, m_signature)
 
-            const bool operator==(const FunctorId& pOther) const
-            {
-                return (m_index == pOther.m_index && m_returnId == pOther.m_returnId && 
-                        m_recordId == pOther.m_recordId && m_containerId == pOther.m_containerId &&
-                        m_signature == pOther.m_signature);
-            }
-        };
-    }
+    /*  @method: getHashCode()
+        @return: std::size_t (a unique hash-code for a functor)
+        * 'm_containerId' will be same for functors(non-member) with same signatures.
+        * for member functions, a functor will have three atrributes
+            - signature
+            - whether it is const or non-const
+            - class/struct type
+            'm_containerId' will be same for functors with same above attributes.
+        * every functor will have a distinct index in the functor-wrapped-lambda-table.
+        * so, combination of m_containerId & m_index is unique for every functor.
+    */  std::size_t getHashCode() const
+        {
+            return std::stoull(std::to_string(m_containerId) +
+                                std::to_string(m_index) +
+                                std::to_string(m_recordId) +
+                                std::to_string(m_returnId));
+        }
+
+        const bool operator==(const FunctorId& pOther) const
+        {
+            return (m_index == pOther.m_index && m_returnId == pOther.m_returnId && 
+                    m_recordId == pOther.m_recordId && m_containerId == pOther.m_containerId &&
+                    m_signature == pOther.m_signature);
+        }
+    };
 }

ReflectionTemplateLib/detail/inc/LambdaTable.h

@@ -0,0 +1,82 @@
+/*************************************************************************
+ *                                                                       *
+ *  Reflection Template Library (RTL) - Modern C++ Reflection Framework  *
+ *  https://github.com/ReflectCxx/ReflectionTemplateLibrary-CPP          *
+ *                                                                       *
+ *  Copyright (c) 2025 Neeraj Singh <reflectcxx@outlook.com>             *
+ *  SPDX-License-Identifier: MIT                                         *
+ *                                                                       *
+ *************************************************************************/
+
+
+#pragma once
+
+#include <vector>
+#include <functional>
+
+#include "Constants.h"
+
+namespace rtl {
+
+	class RObject;
+	struct Return;
+}
+
+namespace rtl::detail
+{
+	class lambda_table { };
+}
+
+
+namespace rtl::detail
+{
+	template<class ...signature_ts>
+	class functors : public lambda_table
+	{
+		using lambda_t = std::function <Return(signature_ts...)>;
+
+		std::vector<lambda_t> m_lambdaTable;
+
+	public:
+
+		GETTER_CREF(std::vector<lambda_t>, , m_lambdaTable)
+
+		void pushBack(const lambda_t& pLambda) {
+			m_lambdaTable.push_back(pLambda);
+		}
+	};
+
+
+	template<class ...signature_ts>
+	class const_functors : public lambda_table
+	{
+		using lambda_t = std::function <Return(const RObject&, signature_ts...)>;
+
+		std::vector<lambda_t> m_lambdaTable;
+
+	public:
+
+		GETTER_CREF(std::vector<lambda_t>, , m_lambdaTable)
+
+		void pushBack(const lambda_t& pLambda) {
+			m_lambdaTable.push_back(pLambda);
+		}
+	};
+
+
+	template<class ...signature_ts>
+	class nonconst_functors : public lambda_table
+	{
+		using lambda_t =  std::function <Return(const RObject&, signature_ts...)>;
+		
+		std::vector<lambda_t> m_lambdaTable;
+
+	public:
+
+		GETTER_CREF(std::vector<lambda_t>, , m_lambdaTable)
+
+		void pushBack(const lambda_t& pLambda) {
+			m_lambdaTable.push_back(pLambda);
+		}
+	};
+}