introduced rtl::Return, removed std::pair<error, RObject>.

neeraj31285 · neeraj31285 · commit 36087b464fa6 · 2025-09-05T22:13:58.000+05:30
diff --git a/CxxTestDesignPatternsUsingRTL/CxxTestProxyDesignPattern/inc/Proxy.h b/CxxTestDesignPatternsUsingRTL/CxxTestProxyDesignPattern/inc/Proxy.h
@@ -30,7 +30,7 @@ namespace proxy_test {
          * @return The result of the function call as a std::any object.
          */
         template<class ..._args>
-        std::pair<rtl::error, rtl::RObject> forwardCall(const std::string& pFunctionName, _args&& ...params);
+        rtl::Return forwardCall(const std::string& pFunctionName, _args&& ...params);
 
         /**
          * @brief Forwards a call to a static method of the "Original" class.
@@ -41,6 +41,6 @@ namespace proxy_test {
          * @return The result of the function call as a std::any object.
          */
         template<class ..._args>
-        static std::pair<rtl::error, rtl::RObject> forwardStaticCall(const std::string& pFunctionName, _args&& ...params);
+        static rtl::Return forwardStaticCall(const std::string& pFunctionName, _args&& ...params);
     };
 }
diff --git a/CxxTestDesignPatternsUsingRTL/CxxTestProxyDesignPattern/inc/Proxy.hpp b/CxxTestDesignPatternsUsingRTL/CxxTestProxyDesignPattern/inc/Proxy.hpp
@@ -15,7 +15,7 @@ namespace proxy_test
      * @return The result of the function call as a std::any object. If the method does not exist or the signature does not match, returns an empty std::any object.
      */
     template<class ..._args>
-    inline std::pair<rtl::error, rtl::RObject> Proxy::forwardCall(const std::string& pFunctionName, _args&& ...params)
+    inline rtl::Return Proxy::forwardCall(const std::string& pFunctionName, _args&& ...params)
     {
         const auto orgMethod = OriginalReflection::getClass()->getMethod(pFunctionName);
         if (!orgMethod.has_value()) {
@@ -40,7 +40,7 @@ namespace proxy_test
      * @return The result of the function call as a std::any object. If the method does not exist or the signature does not match, returns an empty std::any object.
      */
     template<class ..._args>
-    inline std::pair<rtl::error, rtl::RObject> Proxy::forwardStaticCall(const std::string& pFunctionName, _args&& ...params)
+    inline rtl::Return Proxy::forwardStaticCall(const std::string& pFunctionName, _args&& ...params)
     {
         const auto orgMethod = OriginalReflection::getClass()->getMethod(pFunctionName);
         if (!orgMethod.has_value()) {
diff --git a/RTLBenchmarkApp/src/BenchMark.cpp b/RTLBenchmarkApp/src/BenchMark.cpp
@@ -94,21 +94,21 @@ namespace rtl_bench
 		static auto sendMsgCall = sendMsg.bind<const char*>();
 		for (auto _ : state)
 		{
-			benchmark::DoNotOptimize(sendMsgCall.call("reflected"));//*/.call("reflected"));
+			benchmark::DoNotOptimize(sendMsgCall.call("reflected"));
 		}
 	}
 
 
 	void BenchMark::reflectedMethodCall_noReturn(benchmark::State& state)
 	{
-		//rtl::Record rNode = cxx_mirror().getRecord("node").value();
-		//rtl::Method sendMsg = rNode.getMethod("sendMessage").value();
-		//rtl::RObject robj = rNode.create<rtl::alloc::Stack>().second;
-
-		//for (auto _ : state)
-		//{
-		//	benchmark::DoNotOptimize(sendMsg.bind<const char*>(robj).call("reflected"));
-		//}
+		static rtl::Record rNode = cxx_mirror().getRecord("node").value();
+		static rtl::Method sendMsg = rNode.getMethod("sendMessage").value();
+		static rtl::RObject robj = rNode.create<rtl::alloc::Stack>().robj;
+
+		for (auto _ : state)
+		{
+			benchmark::DoNotOptimize(sendMsg.bind<const char*>(robj).call("reflected"));
+		}
 	}
 
 
@@ -146,13 +146,13 @@ namespace rtl_bench
 
 	void BenchMark::reflectedMethodCall_withReturn(benchmark::State& state)
 	{
-		//rtl::Record rNode = cxx_mirror().getRecord("node").value();
-		//rtl::Method getMsg = rNode.getMethod("getMessage").value();
-		//rtl::RObject robj = rNode.create<rtl::alloc::Stack>().second;
-
-		//for (auto _ : state)
-		//{
-		//	benchmark::DoNotOptimize(getMsg.bind<const char*>(robj).call("reflected"));
-		//}
+		static rtl::Record rNode = cxx_mirror().getRecord("node").value();
+		static rtl::Method getMsg = rNode.getMethod("getMessage").value();
+		static rtl::RObject robj = rNode.create<rtl::alloc::Stack>().robj;
+
+		for (auto _ : state)
+		{
+			benchmark::DoNotOptimize(getMsg.bind<const char*>(robj).call("reflected"));
+		}
 	}
 }
diff --git a/RTLBenchmarkApp/src/main.cpp b/RTLBenchmarkApp/src/main.cpp
@@ -11,9 +11,9 @@
 BENCHMARK(rtl_bench::BenchMark::directCall_noReturn);
 BENCHMARK(rtl_bench::BenchMark::lambdaCall_noReturn);
 BENCHMARK(rtl_bench::BenchMark::reflectedCall_noReturn);
-//BENCHMARK(rtl_bench::BenchMark::reflectedMethodCall_noReturn);
-//BENCHMARK(rtl_bench::BenchMark::directCall_withReturn);
-//BENCHMARK(rtl_bench::BenchMark::lambdaCall_withReturn);
-//BENCHMARK(rtl_bench::BenchMark::reflectedCall_withReturn);
-//BENCHMARK(rtl_bench::BenchMark::reflectedMethodCall_withReturn);
+BENCHMARK(rtl_bench::BenchMark::reflectedMethodCall_noReturn);
+BENCHMARK(rtl_bench::BenchMark::directCall_withReturn);
+BENCHMARK(rtl_bench::BenchMark::lambdaCall_withReturn);
+BENCHMARK(rtl_bench::BenchMark::reflectedCall_withReturn);
+BENCHMARK(rtl_bench::BenchMark::reflectedMethodCall_withReturn);
 BENCHMARK_MAIN();
diff --git a/ReflectionTemplateLib/access/inc/Function.h b/ReflectionTemplateLib/access/inc/Function.h
@@ -92,7 +92,7 @@ namespace rtl {
         bool hasSignature() const;
 
         template<class ..._args>
-        std::pair<error, RObject> operator()(_args&&...params) const noexcept;
+        Return operator()(_args&&...params) const noexcept;
 
         template<class ..._signature>
         const detail::FunctionCaller<_signature...> bind() const;
diff --git a/ReflectionTemplateLib/access/inc/Function.hpp b/ReflectionTemplateLib/access/inc/Function.hpp
@@ -37,11 +37,11 @@ namespace rtl
 
     /*  @method: operator()()
         @param: variadic arguments.
-        @return: std::pair<error, RObject>, possible error & return value of from the reflected call.
+        @return: Return, possible error & return value of from the reflected call.
         * if the arguments did not match with any overload, returns RObject with error::SignatureMismatch
         * providing optional syntax, Function::call() does the exact same thing.
     */  template<class ..._args>
-    inline std::pair<error, RObject> Function::operator()(_args&& ...params) const noexcept
+    inline Return Function::operator()(_args&& ...params) const noexcept
     {
         return bind().call(std::forward<_args>(params)...);
     }
diff --git a/ReflectionTemplateLib/access/inc/Method.h b/ReflectionTemplateLib/access/inc/Method.h
@@ -43,7 +43,7 @@ namespace rtl {
 
         //invokes the constructor associated with this 'Method'
         template<class ..._args>
-        std::pair<error, RObject> invokeCtor(alloc&& pAllocType, _args&&...params) const;
+        Return invokeCtor(alloc&& pAllocType, _args&&...params) const;
 
     public:
 
@@ -94,7 +94,7 @@ namespace rtl {
         * provides syntax like, 'method(pTarget)(params...)', keeping the target & params seperate.
     */  constexpr auto operator()(const RObject& pTarget) const
         {
-            return [&](auto&&...params)-> std::pair<error, RObject> {
+            return [&](auto&&...params)-> Return {
                 return bind(pTarget).call(std::forward<decltype(params)>(params)...);
             };
         }
diff --git a/ReflectionTemplateLib/access/inc/Method.hpp b/ReflectionTemplateLib/access/inc/Method.hpp
@@ -34,7 +34,7 @@ namespace rtl
     @return: RStatus
     * calls the constructor with given arguments.
 */  template<class ..._args>
-    inline std::pair<error, RObject> Method::invokeCtor(alloc&& pAllocType, _args&& ...params) const
+    inline Return Method::invokeCtor(alloc&& pAllocType, _args&& ...params) const
     {
         return Function::bind().call<alloc, _args...>(std::forward<alloc>(pAllocType), std::forward<_args>(params)...);
     }
diff --git a/ReflectionTemplateLib/access/inc/RObject.h b/ReflectionTemplateLib/access/inc/RObject.h
@@ -34,6 +34,7 @@ namespace rtl::detail
 
 namespace rtl
 {
+    struct Return;
     class Function;
 
     //Reflecting the object within.
@@ -55,7 +56,7 @@ namespace rtl
         std::size_t getConverterIndex(const std::size_t pToTypeId) const;
 
         template<rtl::alloc _allocOn, detail::EntityKind _entityKind>
-        std::pair<rtl::error, RObject> createCopy() const;
+        Return createCopy() const;
 
         template<class T>
         std::optional<rtl::view<T>> performConversion(const std::size_t pIndex) const;
@@ -83,7 +84,7 @@ namespace rtl
         bool canViewAs() const;
 
         template<rtl::alloc _allocOn, rtl::copy _copyTarget = rtl::copy::Auto>
-        std::pair<rtl::error, RObject> clone() const;
+        Return clone() const;
 
         template<class T, std::enable_if_t<traits::is_unique_ptr_v<T>, int> = 0>
         std::optional<rtl::view<T>> view() const;
@@ -100,4 +101,9 @@ namespace rtl
         friend detail::RObjExtractor;
         friend detail::RObjectBuilder;
     };
+
+    struct [[nodiscard]] Return {
+        error err;
+        RObject robj;
+    };
 }
diff --git a/ReflectionTemplateLib/access/inc/RObject.hpp b/ReflectionTemplateLib/access/inc/RObject.hpp
@@ -41,7 +41,7 @@ namespace rtl
         // Explicitly clear moved-from source
         pOther.m_object.reset();
         pOther.m_objectId = { };
-        pOther.m_getClone = nullptr;
+        //pOther.m_getClone = nullptr;
         pOther.m_converters = nullptr;
     }
 
@@ -161,37 +161,39 @@ namespace rtl
 namespace rtl 
 {
     template<>
-    inline std::pair<error, RObject> RObject::createCopy<alloc::Heap, detail::EntityKind::Value>() const
+    inline Return RObject::createCopy<alloc::Heap, detail::EntityKind::Value>() const
     {
         error err = error::None;
-        return { err, m_getClone(err, *this, alloc::Heap) };
+        RObject robj/*;//*/ = m_getClone(err, *this, alloc::Heap);
+        return { err, std::move(robj) };
     }
 
 
     template<>
-    inline std::pair<error, RObject> RObject::createCopy<alloc::Stack, detail::EntityKind::Value>() const
+    inline Return RObject::createCopy<alloc::Stack, detail::EntityKind::Value>() const
     {
         error err = error::None;
-        return { err, m_getClone(err, *this, alloc::Stack) };
+        RObject robj/*;//*/ = m_getClone(err, *this, alloc::Stack);
+        return { err, std::move(robj) };
     }
 
 
     template<>
-    inline std::pair<error, RObject> RObject::createCopy<alloc::Heap, detail::EntityKind::Wrapper>() const
+    inline Return RObject::createCopy<alloc::Heap, detail::EntityKind::Wrapper>() const
     {
-        return { error::StlWrapperHeapAllocForbidden, RObject{ } };
+        return { error::StlWrapperHeapAllocForbidden, RObject{} };
     }
 
 
     template<>
-    inline std::pair<error, RObject> RObject::createCopy<alloc::Stack, detail::EntityKind::Wrapper>() const
+    inline Return RObject::createCopy<alloc::Stack, detail::EntityKind::Wrapper>() const
     {
         if (m_objectId.m_wrapperType == detail::Wrapper::None) {
-            return { error::NotWrapperType, RObject{ } };
+            return { error::NotWrapperType, RObject{} };
         }
         else if (m_objectId.m_wrapperType == detail::Wrapper::Unique) 
         {
-            return { error::TypeNotCopyConstructible, RObject{ } };
+            return { error::TypeNotCopyConstructible, RObject{} };
         }
         else {
             return { error::None, RObject(*this) };
@@ -200,7 +202,7 @@ namespace rtl
 
 
     template<alloc _allocOn, copy _copyTarget>
-    inline std::pair<error, RObject> RObject::clone() const
+    inline Return RObject::clone() const
     {
         if (isEmpty()) {
             return { error::EmptyRObject, RObject{ } };
diff --git a/ReflectionTemplateLib/access/inc/Record.h b/ReflectionTemplateLib/access/inc/Record.h
@@ -81,15 +81,15 @@ namespace rtl {
 
         /*      @method: create
                 @param: ...params (any number/type of arguments)
-                @return: std::pair<error, RObject>
+                @return: Return
                 * calls the constructor of the calss/struct represented by this 'Record' object.
                 * returns the dynamically allocated object of the calss/struct along with the status.
                 * only default or any other overloaded constructor is called, except copy (for that check, Record::clone()).
                 * if the signature(...params) did not match any registered ctor, error::SignatureMismatch is returned with empty 'RObject'.
                 * if no constructor found, error::ConstructorNotRegisteredInRtl is returned with empty 'RObject'.
                 * on success error::None and newly constructed object wrapped under 'RObject' (type erased, treated as non-const) is returned.
         */      template<alloc _alloc, class ..._ctorArgs>
-        std::pair<error, RObject> create(_ctorArgs&& ...params) const
+        Return create(_ctorArgs&& ...params) const
         {
             static_assert(_alloc != rtl::alloc::None, "Instance cannot be created with 'rtl::alloc::None' option.");
             return m_methods.at(detail::ctor_name(m_recordName)).invokeCtor(_alloc, std::forward<_ctorArgs>(params)...);
diff --git a/ReflectionTemplateLib/detail/inc/CallReflector.h b/ReflectionTemplateLib/detail/inc/CallReflector.h
@@ -31,10 +31,10 @@ namespace rtl {
             * 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 RObject forwardCall(error& pError, std::size_t pFunctorIndex, _params&&..._args)
+            static Return forwardCall(std::size_t pFunctorIndex, _params&&..._args)
             {
                 //'getFunctors()' must be implemented by _derivedType (FunctorContainer).
-                return _derivedType::getFunctors().at(pFunctorIndex)(pError, std::forward<_params>(_args)...);
+                return _derivedType::getFunctors().at(pFunctorIndex)(std::forward<_params>(_args)...);
             }
 
 
@@ -43,10 +43,10 @@ namespace rtl {
             * 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 RObject forwardCall(error& pError, rtl::alloc&& pAllocType, std::size_t pFunctorIndex, _params&&..._args)
+            static Return forwardCall(rtl::alloc&& pAllocType, std::size_t pFunctorIndex, _params&&..._args)
             {
                 //'getFunctors()' must be implemented by _derivedType (FunctorContainer).
-                return _derivedType::getFunctors().at(pFunctorIndex)(pError, std::forward<rtl::alloc>(pAllocType), std::forward<_params>(_args)...);
+                return _derivedType::getFunctors().at(pFunctorIndex)(std::forward<rtl::alloc>(pAllocType), std::forward<_params>(_args)...);
             }
 
 
@@ -55,10 +55,10 @@ namespace rtl {
             * 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 RObject forwardCall(error& pError, const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)
+            static Return forwardCall(const rtl::RObject& pTarget, std::size_t pFunctorIndex, _params&&..._args)
             {
                 //'getMethodFunctors()' is implemented by _derivedType (MethodContainer)
-                return _derivedType::getMethodFunctors().at(pFunctorIndex)(pError, pTarget, std::forward<_params>(_args)...);
+                return _derivedType::getMethodFunctors().at(pFunctorIndex)(pTarget, std::forward<_params>(_args)...);
             }
         };
     }
diff --git a/ReflectionTemplateLib/detail/inc/FunctionCaller.h b/ReflectionTemplateLib/detail/inc/FunctionCaller.h
@@ -15,6 +15,7 @@ namespace rtl
 {
     class RObject;
     class Function;
+    class Return;
 }
 
 namespace rtl::detail
@@ -30,7 +31,7 @@ namespace rtl::detail
     public:
 
         template<class ..._args>
-        std::pair<error, RObject> call(_args&&...) const noexcept;
+        rtl::Return call(_args&&...) const;
 
         friend Function;
     };
diff --git a/ReflectionTemplateLib/detail/inc/FunctionCaller.hpp b/ReflectionTemplateLib/detail/inc/FunctionCaller.hpp
@@ -26,19 +26,16 @@ namespace rtl::detail
 
     template<class ..._signature>
     template<class ..._args>
-    inline std::pair<error, RObject> FunctionCaller<_signature...>::call(_args&&...params) const noexcept
+    inline Return FunctionCaller<_signature...>::call(_args&&...params) const
     {
         using Container = std::conditional_t<sizeof...(_signature) == 0,
                                              FunctorContainer<std::remove_reference_t<_args>...>,
                                              FunctorContainer<_signature...>>;
 
         std::size_t index = m_function.hasSignatureId(Container::getContainerId());
         if (index != rtl::index_none) {
-
-            error err = error::None;
-            return { err, Container::template forwardCall<_args...>(err, index, std::forward<_args>(params)...) };
+            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
@@ -36,7 +36,7 @@ namespace rtl {
                                  public SetupConstructor<FunctorContainer<_signature...>>,
                                  public CallReflector<FunctorContainer<_signature...>>
         {
-            using FunctionLambda = std::function < RObject (error&, _signature...) >;
+            using FunctionLambda = std::function < Return(_signature...) >;
         public:
 
             //every FunctorContainer<...> will have a unique-id.
diff --git a/ReflectionTemplateLib/detail/inc/MethodContainer.h b/ReflectionTemplateLib/detail/inc/MethodContainer.h
@@ -40,7 +40,7 @@ namespace rtl {
         class MethodContainer<detail::methodQ::NonConst, _signature...> : public SetupMethod<MethodContainer<detail::methodQ::NonConst, _signature...>>,
                                                                           public CallReflector<MethodContainer<detail::methodQ::NonConst, _signature...>>
         {
-            using MethodLambda = std::function < RObject (error&, const rtl::RObject&, _signature...) >;
+            using MethodLambda = std::function < Return (const rtl::RObject&, _signature...) >;
 
         public:
 
@@ -111,7 +111,7 @@ namespace rtl {
         class MethodContainer<detail::methodQ::Const, _signature...> : public SetupMethod<MethodContainer<detail::methodQ::Const, _signature...>>,
                                                                        public CallReflector<MethodContainer<detail::methodQ::Const, _signature...>>
         {
-            using MethodLambda = std::function < RObject (error&, const rtl::RObject&, _signature...) >;
+            using MethodLambda = std::function < Return (const rtl::RObject&, _signature...) >;
 
         public:
 
diff --git a/ReflectionTemplateLib/detail/inc/MethodInvoker.h b/ReflectionTemplateLib/detail/inc/MethodInvoker.h
diff --git a/ReflectionTemplateLib/detail/inc/MethodInvoker.hpp b/ReflectionTemplateLib/detail/inc/MethodInvoker.hpp
diff --git a/ReflectionTemplateLib/detail/inc/SetupConstructor.h b/ReflectionTemplateLib/detail/inc/SetupConstructor.h
diff --git a/ReflectionTemplateLib/detail/inc/SetupConstructor.hpp b/ReflectionTemplateLib/detail/inc/SetupConstructor.hpp
diff --git a/ReflectionTemplateLib/detail/inc/SetupFunction.h b/ReflectionTemplateLib/detail/inc/SetupFunction.h
diff --git a/ReflectionTemplateLib/detail/inc/SetupFunction.hpp b/ReflectionTemplateLib/detail/inc/SetupFunction.hpp
diff --git a/ReflectionTemplateLib/detail/inc/SetupMethod.h b/ReflectionTemplateLib/detail/inc/SetupMethod.h
diff --git a/ReflectionTemplateLib/detail/inc/SetupMethod.hpp b/ReflectionTemplateLib/detail/inc/SetupMethod.hpp

Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,11 @@ namespace rtl`
`37`	`37`
`38`	`38`	`/* @method: operator()()`
`39`	`39`	`@param: variadic arguments.`
`40`		`- @return: std::pair<error, RObject>, possible error & return value of from the reflected call.`
	`40`	`+ @return: Return, possible error & return value of from the reflected call.`
`41`	`41`	`* if the arguments did not match with any overload, returns RObject with error::SignatureMismatch`
`42`	`42`	`* providing optional syntax, Function::call() does the exact same thing.`
`43`	`43`	`*/ template<class ..._args>`
`44`		`- inline std::pair<error, RObject> Function::operator()(_args&& ...params) const noexcept`
	`44`	`+ inline Return Function::operator()(_args&& ...params) const noexcept`
`45`	`45`	`{`
`46`	`46`	`return bind().call(std::forward<_args>(params)...);`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ namespace rtl {`
`43`	`43`
`44`	`44`	`//invokes the constructor associated with this 'Method'`
`45`	`45`	`template<class ..._args>`
`46`		`- std::pair<error, RObject> invokeCtor(alloc&& pAllocType, _args&&...params) const;`
	`46`	`+ Return invokeCtor(alloc&& pAllocType, _args&&...params) const;`
`47`	`47`
`48`	`48`	`public:`
`49`	`49`
`@@ -94,7 +94,7 @@ namespace rtl {`
`94`	`94`	`* provides syntax like, 'method(pTarget)(params...)', keeping the target & params seperate.`
`95`	`95`	`*/ constexpr auto operator()(const RObject& pTarget) const`
`96`	`96`	`{`
`97`		`- return [&](auto&&...params)-> std::pair<error, RObject> {`
	`97`	`+ return [&](auto&&...params)-> Return {`
`98`	`98`	`return bind(pTarget).call(std::forward<decltype(params)>(params)...);`
`99`	`99`	`};`
`100`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ namespace rtl`
`34`	`34`	`@return: RStatus`
`35`	`35`	`* calls the constructor with given arguments.`
`36`	`36`	`*/ template<class ..._args>`
`37`		`- inline std::pair<error, RObject> Method::invokeCtor(alloc&& pAllocType, _args&& ...params) const`
	`37`	`+ inline Return Method::invokeCtor(alloc&& pAllocType, _args&& ...params) const`
`38`	`38`	`{`
`39`	`39`	`return Function::bind().call<alloc, _args...>(std::forward<alloc>(pAllocType), std::forward<_args>(params)...);`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ namespace rtl`
`41`	`41`	`// Explicitly clear moved-from source`
`42`	`42`	`pOther.m_object.reset();`
`43`	`43`	`pOther.m_objectId = { };`
`44`		`- pOther.m_getClone = nullptr;`
	`44`	`+ //pOther.m_getClone = nullptr;`
`45`	`45`	`pOther.m_converters = nullptr;`
`46`	`46`	`}`
`47`	`47`
`@@ -161,37 +161,39 @@ namespace rtl`
`161`	`161`	`namespace rtl`
`162`	`162`	`{`
`163`	`163`	`template<>`
`164`		`- inline std::pair<error, RObject> RObject::createCopy<alloc::Heap, detail::EntityKind::Value>() const`
	`164`	`+ inline Return RObject::createCopy<alloc::Heap, detail::EntityKind::Value>() const`
`165`	`165`	`{`
`166`	`166`	`error err = error::None;`
`167`		`- return { err, m_getClone(err, *this, alloc::Heap) };`
	`167`	`+ RObject robj/;/// = m_getClone(err, *this, alloc::Heap);`
	`168`	`+ return { err, std::move(robj) };`
`168`	`169`	`}`
`169`	`170`
`170`	`171`
`171`	`172`	`template<>`
`172`		`- inline std::pair<error, RObject> RObject::createCopy<alloc::Stack, detail::EntityKind::Value>() const`
	`173`	`+ inline Return RObject::createCopy<alloc::Stack, detail::EntityKind::Value>() const`
`173`	`174`	`{`
`174`	`175`	`error err = error::None;`
`175`		`- return { err, m_getClone(err, *this, alloc::Stack) };`
	`176`	`+ RObject robj/;/// = m_getClone(err, *this, alloc::Stack);`
	`177`	`+ return { err, std::move(robj) };`
`176`	`178`	`}`
`177`	`179`
`178`	`180`
`179`	`181`	`template<>`
`180`		`- inline std::pair<error, RObject> RObject::createCopy<alloc::Heap, detail::EntityKind::Wrapper>() const`
	`182`	`+ inline Return RObject::createCopy<alloc::Heap, detail::EntityKind::Wrapper>() const`
`181`	`183`	`{`
`182`		`- return { error::StlWrapperHeapAllocForbidden, RObject{ } };`
	`184`	`+ return { error::StlWrapperHeapAllocForbidden, RObject{} };`
`183`	`185`	`}`
`184`	`186`
`185`	`187`
`186`	`188`	`template<>`
`187`		`- inline std::pair<error, RObject> RObject::createCopy<alloc::Stack, detail::EntityKind::Wrapper>() const`
	`189`	`+ inline Return RObject::createCopy<alloc::Stack, detail::EntityKind::Wrapper>() const`
`188`	`190`	`{`
`189`	`191`	`if (m_objectId.m_wrapperType == detail::Wrapper::None) {`
`190`		`- return { error::NotWrapperType, RObject{ } };`
	`192`	`+ return { error::NotWrapperType, RObject{} };`
`191`	`193`	`}`
`192`	`194`	`else if (m_objectId.m_wrapperType == detail::Wrapper::Unique)`
`193`	`195`	`{`
`194`		`- return { error::TypeNotCopyConstructible, RObject{ } };`
	`196`	`+ return { error::TypeNotCopyConstructible, RObject{} };`
`195`	`197`	`}`
`196`	`198`	`else {`
`197`	`199`	`return { error::None, RObject(*this) };`
`@@ -200,7 +202,7 @@ namespace rtl`
`200`	`202`
`201`	`203`
`202`	`204`	`template<alloc _allocOn, copy _copyTarget>`
`203`		`- inline std::pair<error, RObject> RObject::clone() const`
	`205`	`+ inline Return RObject::clone() const`
`204`	`206`	`{`
`205`	`207`	`if (isEmpty()) {`
`206`	`208`	`return { error::EmptyRObject, RObject{ } };`