removed .at(), static-cache encouraging inlining, BM with functor-dref.

neeraj31285 · neeraj31285 · commit 7bfc6c824d7a · 2025-09-10T14:21:42.000+05:30
diff --git a/CxxTestProps/src/Date.cpp b/CxxTestProps/src/Date.cpp
@@ -151,12 +151,12 @@ namespace nsdate
 		vector<string> date;
 		for (size_t i = 0; i < pDateStr.length(); i++)
 		{
-			if (pDateStr.at(i) == '/') {
+			if (pDateStr[i] == '/') {
 				date.push_back(strBuf);
 				strBuf.clear();
 			}
 			else {
-				strBuf.push_back(pDateStr.at(i));
+				strBuf.push_back(pDateStr[i]);
 			}
 		}
 		m_day = stoi(date[0]);
@@ -208,12 +208,12 @@ namespace nsdate
 		vector<string> date;
 		for (size_t i = 0; i < pDateStr.length(); i++)
 		{
-			if (pDateStr.at(i) == '/') {
+			if (pDateStr[i] == '/') {
 				date.push_back(strBuf);
 				strBuf.clear();
 			}
 			else {
-				strBuf.push_back(pDateStr.at(i));
+				strBuf.push_back(pDateStr[i]);
 			}
 		}
 		m_day = stoi(date[0]);
diff --git a/RTLBenchmarkApp/src/BenchMark.cpp b/RTLBenchmarkApp/src/BenchMark.cpp
@@ -9,24 +9,31 @@
 namespace {
 
     static const char* LONG_STR = "Lorem ipsum";
-    //    dolor sit amet, consectetur adipiscing elit, sed do"
-    //"do aeiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis"
-    //"nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure"
-    //"dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Except"
-    //"eur ssint occaecat cupidatat nnon proident, sunt in culpa qui officia deserunt mollit anim id"
-    //"Lorem ipsum dolor sit amet laboris nisi ut aliquip ex ea commodo";
+    //  dolor sit amet, consectetur adipiscing elit, sed do"
+    // "do aeiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis"
+    // "nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure"
+    // "dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Except"
+    // "eur ssint occaecat cupidatat nnon proident, sunt in culpa qui officia deserunt mollit anim id"
+    // "Lorem ipsum dolor sit amet laboris nisi ut aliquip ex ea commodo";
 }
 
 // Pre-created string to isolate call overhead
-static argStr_t g_longStr(LONG_STR);
+argStr_t g_longStr(LONG_STR);
+
+extern decltype(&rtl_bench::getMessage) getMessagePtr;
+extern decltype(&rtl_bench::sendMessage) sendMessagePtr;    
+extern decltype(&rtl_bench::Node::getMessage) getMessageNodePtr;
+extern decltype(&rtl_bench::Node::sendMessage) sendMessageNodePtr;
 
 namespace rtl_bench
 {
+    static Node* node = new Node();
+
     void BenchMark::directCall_noReturn(benchmark::State& state)
     {
         for (auto _ : state)
         {
-            sendMessage(g_longStr);
+            sendMessagePtr(g_longStr);
             benchmark::DoNotOptimize(g_msg);
         }
     }
@@ -35,7 +42,7 @@ namespace rtl_bench
     void BenchMark::stdFunctionCall_noReturn(benchmark::State& state)
     {
         static std::function sendMsg = [](argStr_t& pMsg) {
-            sendMessage(pMsg);
+            sendMessagePtr(pMsg);
         };
 
         for (auto _ : state)
@@ -45,12 +52,10 @@ namespace rtl_bench
         }
     }
 
-
     void BenchMark::stdFunctionMethodCall_noReturn(benchmark::State& state)
     {
-        Node* node = new Node();
         static std::function sendMsg = [=](argStr_t& pMsg) {
-            node->sendMessage(pMsg);
+            (node->*sendMessageNodePtr)(pMsg);
         };
 
         for (auto _ : state)
@@ -79,10 +84,7 @@ namespace rtl_bench
     void BenchMark::stdFunctionCall_withReturn(benchmark::State& state)
     {
         static std::function getMsg = [](argStr_t& pMsg) {
-            auto msgStr = getMessage(pMsg);
-            volatile auto* p = &msgStr; 
-            static_cast<void>(p);
-            return msgStr;
+            return getMessagePtr(pMsg);
         };
 
         for (auto _ : state)
@@ -94,12 +96,8 @@ namespace rtl_bench
 
     void BenchMark::stdFunctionMethodCall_withReturn(benchmark::State& state)
     {
-        static Node* node = new Node();
         static std::function getMsg = [=](argStr_t& pMsg) {
-            auto msgStr = node->getMessage(pMsg);
-            volatile auto* p = &msgStr; 
-            static_cast<void>(p);
-            return msgStr;
+            return (node->*getMessageNodePtr)(pMsg);
         };
 
         for (auto _ : state)
diff --git a/RTLBenchmarkApp/src/BenchMark.h b/RTLBenchmarkApp/src/BenchMark.h
@@ -2,6 +2,8 @@
 
 #include <benchmark/benchmark.h>
 
+#include <vector>
+
 #include "RTLibInterface.h"
 
 #if defined(_MSC_VER)
@@ -17,44 +19,31 @@ using retStr_t = std::string_view;
 
 #define WORK_LOAD(S) (std::string(S))
 
-
 namespace rtl_bench
 {
     static std::optional<std::string> g_msg;
 
     NOINLINE static void sendMessage(argStr_t pMsg) 
     {
-        std::string str = WORK_LOAD(pMsg);
-        volatile auto* p = &str;
-        static_cast<void>(p);
-        g_msg = str;
+        g_msg = WORK_LOAD(pMsg);
     }
 
     NOINLINE static retStr_t getMessage(argStr_t pMsg)
     {
-        std::string str = WORK_LOAD(pMsg);
-        volatile auto* p = &str;
-        static_cast<void>(p);
-        g_msg = str;
+        g_msg = WORK_LOAD(pMsg);
         return retStr_t(g_msg->c_str());
     }
 
     struct Node
     {
         NOINLINE void sendMessage(argStr_t pMsg) 
         {
-            std::string str = WORK_LOAD(pMsg);
-            volatile auto* p = &str;
-            static_cast<void>(p);
-    	    g_msg = str;
+            g_msg = WORK_LOAD(pMsg);
         }
 
         NOINLINE retStr_t getMessage(argStr_t pMsg)
         {
-            std::string str = WORK_LOAD(pMsg);
-            volatile auto* p = &str;
-            static_cast<void>(p);
-            g_msg = str;
+            g_msg = WORK_LOAD(pMsg);
             return retStr_t(g_msg->c_str());
         }
     };
diff --git a/RTLBenchmarkApp/src/main.cpp b/RTLBenchmarkApp/src/main.cpp
@@ -4,6 +4,10 @@
 
 #include "BenchMark.h"
 
+auto sendMessagePtr = rtl_bench::sendMessage;
+auto getMessagePtr = rtl_bench::getMessage;
+auto sendMessageNodePtr = &rtl_bench::Node::sendMessage;
+auto getMessageNodePtr = &rtl_bench::Node::getMessage;
 
 BENCHMARK(rtl_bench::BenchMark::directCall_noReturn);
 BENCHMARK(rtl_bench::BenchMark::stdFunctionCall_noReturn);
diff --git a/ReflectionTemplateLib/access/inc/Function.hpp b/ReflectionTemplateLib/access/inc/Function.hpp
@@ -57,7 +57,7 @@ namespace rtl
     {
         //simple linear-search, efficient for small set of elements.
         for (const auto& functorId : m_functorIds) {
-            if (functorId.getSignatureId() == pSignatureId) {
+            if (functorId.getSignatureId() == pSignatureId) [[likely]] {
                 return functorId.getIndex();
             }
         }
diff --git a/ReflectionTemplateLib/access/inc/RObject.hpp b/ReflectionTemplateLib/access/inc/RObject.hpp
@@ -182,7 +182,7 @@ namespace rtl
         std::size_t pClonerIndex = m_objectId.m_clonerIndex;
         if (pClonerIndex != rtl::index_none)
         {
-            return traits::Cloner::template forwardCall(pClonerIndex, alloc::Heap, pClonerIndex, *this);
+            return traits::Cloner::template forwardCall<const RObject&>(pClonerIndex, alloc::Heap, pClonerIndex, *this);
         }
         return { error::CloningDisabled, RObject() };
     }
@@ -194,7 +194,7 @@ namespace rtl
         std::size_t pClonerIndex = m_objectId.m_clonerIndex;
         if (pClonerIndex != rtl::index_none)
         {
-            return traits::Cloner::template forwardCall(pClonerIndex, alloc::Stack, pClonerIndex, *this);
+            return traits::Cloner::template forwardCall<const RObject&>(pClonerIndex, alloc::Stack, pClonerIndex, *this);
         }
         return { error::CloningDisabled, RObject() };
     }
diff --git a/ReflectionTemplateLib/access/inc/Record.h b/ReflectionTemplateLib/access/inc/Record.h
@@ -65,6 +65,7 @@ namespace rtl {
 
         GETTER_CREF(MethodMap, MethodMap, m_methods)
         GETTER_CREF(std::string, RecordName, m_recordName)
+        
 /*      @method: getMethod
         @param: const std::string& (name of the method)
         @return: std::optional<Method>
@@ -93,7 +94,7 @@ namespace rtl {
         {
             static_assert(_alloc != rtl::alloc::None, "Instance cannot be created with 'rtl::alloc::None' option.");
             const auto& method = m_methods.at(detail::ctor_name(m_recordName));
-            std::size_t copyCtorIndex = method.getFunctorIds().at(detail::Index::CopyCtor).getIndex();
+            std::size_t copyCtorIndex = method.getFunctorIds()[detail::Index::CopyCtor].getIndex();
             return method.invokeCtor( _alloc,
                                       std::move(copyCtorIndex),
                                       std::forward<_ctorArgs>(params)...);
diff --git a/ReflectionTemplateLib/access/src/CxxMirror.cpp b/ReflectionTemplateLib/access/src/CxxMirror.cpp
@@ -25,14 +25,14 @@ namespace rtl
         }
     }
 
-    error CxxMirror::enableCloning(const RObject& pTarget) const 
+    error CxxMirror::enableCloning(const RObject& pTarget) const
     {
         const auto& itr = getRecordIdMap().find(pTarget.getTypeId());
         if (itr != getRecordIdMap().end()) 
         {
             const Record& record = itr->second;
             Method ctors = record.getMethod(detail::ctor_name(record.getRecordName())).value();
-            const_cast<RObject&>(pTarget).m_objectId.m_clonerIndex = ctors.getFunctors().at(detail::Index::CopyCtor).getIndex();
+            const_cast<RObject&>(pTarget).m_objectId.m_clonerIndex = ctors.getFunctors()[detail::Index::CopyCtor].getIndex();
             return error::None;
         }
         return error::CloningDisabled;
diff --git a/ReflectionTemplateLib/detail/inc/CallReflector.h b/ReflectionTemplateLib/detail/inc/CallReflector.h
@@ -30,10 +30,10 @@ 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>
-        static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)
+        FORCE_INLINE static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)
         {
             //'getFunctors()' must be implemented by _derivedType (FunctorContainer).
-            return _derivedType::getFunctors().at(pFunctorIndex)(std::forward<_params>(_args)...);
+            return _derivedType::getFunctors()[pFunctorIndex](std::forward<_params>(_args)...);
         }
 
 
@@ -42,10 +42,10 @@ 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 constructors.
     */  template<class ..._params>
-        static Return forwardCall(std::size_t pFunctorIndex, rtl::alloc pAllocType, std::size_t pClonerIndex, _params&&..._args)
+        FORCE_INLINE static Return forwardCall(std::size_t pFunctorIndex, rtl::alloc pAllocType, std::size_t pClonerIndex, _params&&..._args)
         {
             //'getFunctors()' must be implemented by _derivedType (FunctorContainer).
-            return _derivedType::getFunctors().at(pFunctorIndex)(pAllocType, pClonerIndex, std::forward<_params>(_args)...);
+            return _derivedType::getFunctors()[pFunctorIndex](pAllocType, pClonerIndex, std::forward<_params>(_args)...);
         }
 
 
@@ -54,10 +54,10 @@ 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 member-function functors.
     */  template<class ..._params>
-        static Return forwardCall(const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)
+        FORCE_INLINE static Return forwardCall(const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)
         {
             //'getMethodFunctors()' is implemented by _derivedType (MethodContainer)
-            return _derivedType::getMethodFunctors().at(pFunctorIndex)(pTarget, std::forward<_params>(_args)...);
+            return _derivedType::getMethodFunctors()[pFunctorIndex](pTarget, std::forward<_params>(_args)...);
         }
     };
 }
diff --git a/ReflectionTemplateLib/detail/inc/FunctionCaller.hpp b/ReflectionTemplateLib/detail/inc/FunctionCaller.hpp
@@ -33,7 +33,7 @@ namespace rtl::detail
                                              FunctorContainer<_signature...>>;
 
         std::size_t index = m_function.hasSignatureId(Container::getContainerId());
-        if (index != rtl::index_none) {
+        if (index != rtl::index_none) [[likely]] {
             return Container::template forwardCall<_args...>(index, std::forward<_args>(params)...);
         }
         return { error::SignatureMismatch, RObject{} };
diff --git a/ReflectionTemplateLib/detail/inc/FunctorContainer.h b/ReflectionTemplateLib/detail/inc/FunctorContainer.h
@@ -40,14 +40,15 @@ namespace rtl {
         public:
 
             //every FunctorContainer<...> will have a unique-id.
-            static std::size_t getContainerId() {
+            FORCE_INLINE static std::size_t getContainerId() {
                 static const std::size_t containerId = generate_unique_id();
                 return containerId;
             }
 
             //get the vector holding lambdas as 'const-ref'
-            const static std::vector<FunctionLambda>& getFunctors() {
-                return getFunctorTable();
+            FORCE_INLINE const static std::vector<FunctionLambda>& getFunctors() {
+                static std::vector<FunctionLambda>& functorTable = getFunctorTable();
+                return functorTable;
             }
 
             //get functor container type(_signature...) as string with given 'returnType'.
diff --git a/ReflectionTemplateLib/detail/inc/MethodContainer.h b/ReflectionTemplateLib/detail/inc/MethodContainer.h
@@ -52,8 +52,9 @@ namespace rtl {
             }
 
             //get the vector holding lambdas as 'const-ref'
-            static const std::vector<MethodLambda>& getMethodFunctors() {
-                return getFunctorTable();
+            FORCE_INLINE static const std::vector<MethodLambda>& getMethodFunctors() {
+                static std::vector<MethodLambda>& functorTable = getFunctorTable();
+                return functorTable;
             }
 
             //get container type as string
@@ -116,15 +117,16 @@ namespace rtl {
         public:
 
             //every MethodContainer<detail::methodQ::Const,...> will have a unique-id.
-            static std::size_t getContainerId() {
+            FORCE_INLINE static std::size_t getContainerId() {
                 //holds unique-id
                 static const std::size_t containerId = generate_unique_id();
                 return containerId;
             }
 
             //get the vector holding lambdas as 'const-ref'
-            static const std::vector<MethodLambda>& getMethodFunctors() {
-                return  getFunctorTable();
+            FORCE_INLINE static const std::vector<MethodLambda>& getMethodFunctors() {
+                static std::vector<MethodLambda>& functorTable = getFunctorTable();
+                return functorTable;
             }
 
             //get container type as string
diff --git a/ReflectionTemplateLib/detail/inc/SetupConstructor.hpp b/ReflectionTemplateLib/detail/inc/SetupConstructor.hpp
@@ -124,13 +124,13 @@ namespace rtl::detail
         //will be called from '_derivedType' if the constructor not already registered.
         const auto& updateIndex = [&](std::size_t pIndex)->void {
             ctorSet.insert(std::make_pair(hashKey, pIndex));
-            };
+        };
 
         //will be called from '_derivedType' to check if the constructor already registered.
         const auto& getIndex = [&]()-> std::size_t {
             const auto& itr = ctorSet.find(hashKey);
             return (itr != ctorSet.end() ? itr->second : index_none);
-            };
+        };
 
         //add the lambda in 'FunctorContainer'.
         std::size_t index = _derivedType::pushBack(getConstructorCaller<_recordType, _signature...>(), getIndex, updateIndex);

Original file line number	Diff line number	Diff line change
`@@ -151,12 +151,12 @@ namespace nsdate`
`151`	`151`	`vector<string> date;`
`152`	`152`	`for (size_t i = 0; i < pDateStr.length(); i++)`
`153`	`153`	`{`
`154`		`- if (pDateStr.at(i) == '/') {`
	`154`	`+ if (pDateStr[i] == '/') {`
`155`	`155`	`date.push_back(strBuf);`
`156`	`156`	`strBuf.clear();`
`157`	`157`	`}`
`158`	`158`	`else {`
`159`		`- strBuf.push_back(pDateStr.at(i));`
	`159`	`+ strBuf.push_back(pDateStr[i]);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`	`m_day = stoi(date[0]);`
`@@ -208,12 +208,12 @@ namespace nsdate`
`208`	`208`	`vector<string> date;`
`209`	`209`	`for (size_t i = 0; i < pDateStr.length(); i++)`
`210`	`210`	`{`
`211`		`- if (pDateStr.at(i) == '/') {`
	`211`	`+ if (pDateStr[i] == '/') {`
`212`	`212`	`date.push_back(strBuf);`
`213`	`213`	`strBuf.clear();`
`214`	`214`	`}`
`215`	`215`	`else {`
`216`		`- strBuf.push_back(pDateStr.at(i));`
	`216`	`+ strBuf.push_back(pDateStr[i]);`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`m_day = stoi(date[0]);`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`
`3`	`3`	`#include <benchmark/benchmark.h>`
`4`	`4`
	`5`	`+#include <vector>`
	`6`	`+`
`5`	`7`	`#include "RTLibInterface.h"`
`6`	`8`
`7`	`9`	`#if defined(_MSC_VER)`
`@@ -17,44 +19,31 @@ using retStr_t = std::string_view;`
`17`	`19`
`18`	`20`	`#define WORK_LOAD(S) (std::string(S))`
`19`	`21`
`20`		`-`
`21`	`22`	`namespace rtl_bench`
`22`	`23`	`{`
`23`	`24`	`static std::optional<std::string> g_msg;`
`24`	`25`
`25`	`26`	`NOINLINE static void sendMessage(argStr_t pMsg)`
`26`	`27`	`{`
`27`		`- std::string str = WORK_LOAD(pMsg);`
`28`		`- volatile auto* p = &str;`
`29`		`- static_cast<void>(p);`
`30`		`- g_msg = str;`
	`28`	`+ g_msg = WORK_LOAD(pMsg);`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`NOINLINE static retStr_t getMessage(argStr_t pMsg)`
`34`	`32`	`{`
`35`		`- std::string str = WORK_LOAD(pMsg);`
`36`		`- volatile auto* p = &str;`
`37`		`- static_cast<void>(p);`
`38`		`- g_msg = str;`
	`33`	`+ g_msg = WORK_LOAD(pMsg);`
`39`	`34`	`return retStr_t(g_msg->c_str());`
`40`	`35`	`}`
`41`	`36`
`42`	`37`	`struct Node`
`43`	`38`	`{`
`44`	`39`	`NOINLINE void sendMessage(argStr_t pMsg)`
`45`	`40`	`{`
`46`		`- std::string str = WORK_LOAD(pMsg);`
`47`		`- volatile auto* p = &str;`
`48`		`- static_cast<void>(p);`
`49`		`- g_msg = str;`
	`41`	`+ g_msg = WORK_LOAD(pMsg);`
`50`	`42`	`}`
`51`	`43`
`52`	`44`	`NOINLINE retStr_t getMessage(argStr_t pMsg)`
`53`	`45`	`{`
`54`		`- std::string str = WORK_LOAD(pMsg);`
`55`		`- volatile auto* p = &str;`
`56`		`- static_cast<void>(p);`
`57`		`- g_msg = str;`
	`46`	`+ g_msg = WORK_LOAD(pMsg);`
`58`	`47`	`return retStr_t(g_msg->c_str());`
`59`	`48`	`}`
`60`	`49`	`};`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ namespace rtl`
`57`	`57`	`{`
`58`	`58`	`//simple linear-search, efficient for small set of elements.`
`59`	`59`	`for (const auto& functorId : m_functorIds) {`
`60`		`- if (functorId.getSignatureId() == pSignatureId) {`
	`60`	`+ if (functorId.getSignatureId() == pSignatureId) [[likely]] {`
`61`	`61`	`return functorId.getIndex();`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ namespace rtl`
`182`	`182`	`std::size_t pClonerIndex = m_objectId.m_clonerIndex;`
`183`	`183`	`if (pClonerIndex != rtl::index_none)`
`184`	`184`	`{`
`185`		`- return traits::Cloner::template forwardCall(pClonerIndex, alloc::Heap, pClonerIndex, *this);`
	`185`	`+ return traits::Cloner::template forwardCall<const RObject&>(pClonerIndex, alloc::Heap, pClonerIndex, *this);`
`186`	`186`	`}`
`187`	`187`	`return { error::CloningDisabled, RObject() };`
`188`	`188`	`}`
`@@ -194,7 +194,7 @@ namespace rtl`
`194`	`194`	`std::size_t pClonerIndex = m_objectId.m_clonerIndex;`
`195`	`195`	`if (pClonerIndex != rtl::index_none)`
`196`	`196`	`{`
`197`		`- return traits::Cloner::template forwardCall(pClonerIndex, alloc::Stack, pClonerIndex, *this);`
	`197`	`+ return traits::Cloner::template forwardCall<const RObject&>(pClonerIndex, alloc::Stack, pClonerIndex, *this);`
`198`	`198`	`}`
`199`	`199`	`return { error::CloningDisabled, RObject() };`
`200`	`200`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ namespace rtl`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`- error CxxMirror::enableCloning(const RObject& pTarget) const`
	`28`	`+ error CxxMirror::enableCloning(const RObject& pTarget) const`
`29`	`29`	`{`
`30`	`30`	`const auto& itr = getRecordIdMap().find(pTarget.getTypeId());`
`31`	`31`	`if (itr != getRecordIdMap().end())`
`32`	`32`	`{`
`33`	`33`	`const Record& record = itr->second;`
`34`	`34`	`Method ctors = record.getMethod(detail::ctor_name(record.getRecordName())).value();`
`35`		`- const_cast<RObject&>(pTarget).m_objectId.m_clonerIndex = ctors.getFunctors().at(detail::Index::CopyCtor).getIndex();`
	`35`	`+ const_cast<RObject&>(pTarget).m_objectId.m_clonerIndex = ctors.getFunctors()[detail::Index::CopyCtor].getIndex();`
`36`	`36`	`return error::None;`
`37`	`37`	`}`
`38`	`38`	`return error::CloningDisabled;`
Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,10 @@ namespace rtl::detail {`
`30`	`30`	`* gets the lambda vector from '_derivedType' and calls the lambda at given index with '_args'.`
`31`	`31`	`* this 'forwardCall' is for calling lambda containing non-member-function and static-member-function functors.`
`32`	`32`	`*/ template<class ..._params>`
`33`		`- static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)`
	`33`	`+ FORCE_INLINE static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)`
`34`	`34`	`{`
`35`	`35`	`//'getFunctors()' must be implemented by _derivedType (FunctorContainer).`
`36`		`- return _derivedType::getFunctors().at(pFunctorIndex)(std::forward<_params>(_args)...);`
	`36`	`+ return _derivedType::getFunctors()[pFunctorIndex](std::forward<_params>(_args)...);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`
`@@ -42,10 +42,10 @@ namespace rtl::detail {`
`42`	`42`	`* gets the lambda vector from '_derivedType' and calls the lambda at given index with '_args'.`
`43`	`43`	`* this 'forwardCall' is for calling lambda containing constructors.`
`44`	`44`	`*/ template<class ..._params>`
`45`		`- static Return forwardCall(std::size_t pFunctorIndex, rtl::alloc pAllocType, std::size_t pClonerIndex, _params&&..._args)`
	`45`	`+ FORCE_INLINE static Return forwardCall(std::size_t pFunctorIndex, rtl::alloc pAllocType, std::size_t pClonerIndex, _params&&..._args)`
`46`	`46`	`{`
`47`	`47`	`//'getFunctors()' must be implemented by _derivedType (FunctorContainer).`
`48`		`- return _derivedType::getFunctors().at(pFunctorIndex)(pAllocType, pClonerIndex, std::forward<_params>(_args)...);`
	`48`	`+ return _derivedType::getFunctors()[pFunctorIndex](pAllocType, pClonerIndex, std::forward<_params>(_args)...);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`
`@@ -54,10 +54,10 @@ namespace rtl::detail {`
`54`	`54`	`* gets the lambda vector from '_derivedType' and calls the lambda at given index with '_args'.`
`55`	`55`	`* this 'forwardCall' is for calling lambda containing member-function functors.`
`56`	`56`	`*/ template<class ..._params>`
`57`		`- static Return forwardCall(const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)`
	`57`	`+ FORCE_INLINE static Return forwardCall(const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)`
`58`	`58`	`{`
`59`	`59`	`//'getMethodFunctors()' is implemented by _derivedType (MethodContainer)`
`60`		`- return _derivedType::getMethodFunctors().at(pFunctorIndex)(pTarget, std::forward<_params>(_args)...);`
	`60`	`+ return _derivedType::getMethodFunctors()[pFunctorIndex](pTarget, std::forward<_params>(_args)...);`
`61`	`61`	`}`
`62`	`62`	`};`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ namespace rtl::detail`
`33`	`33`	`FunctorContainer<_signature...>>;`
`34`	`34`
`35`	`35`	`std::size_t index = m_function.hasSignatureId(Container::getContainerId());`
`36`		`- if (index != rtl::index_none) {`
	`36`	`+ if (index != rtl::index_none) [[likely]] {`
`37`	`37`	`return Container::template forwardCall<_args...>(index, std::forward<_args>(params)...);`
`38`	`38`	`}`
`39`	`39`	`return { error::SignatureMismatch, RObject{} };`