comments added

Author: neeraj31285

CxxReflectionTests/src/ConstMethodOverloadTests.cpp

@@ -69,6 +69,42 @@ namespace rtl_tests
 	}
 
 
+	TEST(ConstMethodOverload, const_method_no_overload_call_on_const_target_returns_string)
+	{
+		{
+			CxxMirror& cxxMirror = MyReflection::instance();
+
+			optional<Record> recOpt = cxxMirror.getRecord(person::class_);
+			ASSERT_TRUE(recOpt.has_value());
+
+			const Record& classPerson = recOpt.value();
+			optional<Method> updateLastName = classPerson.getMethod(person::str_updateLastName);
+			ASSERT_TRUE(updateLastName);
+
+			const std::string firstName = person::FIRST_NAME;
+			auto [status, personObj] = classPerson.instance(firstName);
+
+			ASSERT_TRUE(status);
+			ASSERT_FALSE(personObj.isEmpty());
+
+			personObj.makeConst();
+			ASSERT_TRUE(personObj.isConst());
+
+			optional<Method> getFirstName = classPerson.getMethod(person::str_getFirstName);
+			ASSERT_TRUE(getFirstName);
+
+			const RStatus& rstatus = getFirstName->on(personObj).call();
+			ASSERT_TRUE(rstatus);
+			ASSERT_TRUE(rstatus.isOfType<std::string>());
+
+			const std::string retStr = std::any_cast<std::string>(rstatus.getReturn());
+			ASSERT_EQ(retStr, firstName);
+		}
+		EXPECT_TRUE(person::assert_zero_instance_count());
+		EXPECT_TRUE(Instance::getInstanceCount() == 0);
+	}
+
+
 	TEST(ConstMethodOverload, const_method_string_call_on_const_target)
 	{
 		{

CxxTestProject/inc/Person.h

@@ -22,6 +22,8 @@ class Person
 
     void updateAddress() const;
 
+    std::string getFirstName() const;
+
     void updateAddress(std::string pAddress);
 
     void updateAddress(std::string pAddress) const;

CxxTestProject/src/Person.cpp

@@ -62,6 +62,12 @@ void Person::updateAddress() const
 }
 
 
+std::string Person::getFirstName() const
+{
+	return m_firstName;
+}
+
+
 const bool Person::operator==(const Person& pOther) const
 {
 	return (m_address == pOther.m_address && m_firstName == pOther.m_firstName && m_lastName == pOther.m_lastName);

CxxTypeRegistration/inc/TestUtilsPerson.h

@@ -21,6 +21,7 @@ namespace test_utils
 		static constexpr const char* class_ = "Person";
 		static constexpr const char* str_getProfile = "getProfile";
 		static constexpr const char* str_getDefaults = "getDefaults";
+		static constexpr const char* str_getFirstName = "getFirstName";
 		static constexpr const char* str_updateAddress = "updateAddress";
 		static constexpr const char* str_updateLastName = "updateLastName";
 

CxxTypeRegistration/src/MyReflection.cpp

@@ -69,6 +69,7 @@ CxxMirror& MyReflection::instance()
         Reflect().record<Person>(person::class_).constructor<const Person&>().build(),  //copy constructor taking const ref argument.
         Reflect().record<Person>(person::class_).method<void>(person::str_updateAddress).build(&Person::updateAddress),
         Reflect().record<Person>(person::class_).method<string>(person::str_updateAddress).build(&Person::updateAddress),
+        Reflect().record<Person>(person::class_).methodConst(person::str_getFirstName).build(&Person::getFirstName),
         Reflect().record<Person>(person::class_).methodConst(person::str_updateLastName).build(&Person::updateLastName),  //const method registration, 'methodConst()' function must be used. compiler error otherwise.
         Reflect().record<Person>(person::class_).methodConst<void>(person::str_updateAddress).build(&Person::updateAddress),
         Reflect().record<Person>(person::class_).methodConst<string>(person::str_updateAddress).build(&Person::updateAddress),  //overloaded method based on 'const'.

ReflectionTemplateLib/access/inc/CxxMirror.h

@@ -20,13 +20,13 @@ namespace rtl {
         * all the type registration is done while constructing its object.
         * its objects can be createed locally and will be destroyed as regular object, at scope's end.
         * deleted copy constructor and assignment operator, can only be passed around as reference or wrapped in a smart pointer.
-        * the inherited data members are freed upon destruction, except the functors (function/method pointer) tables, they have static lifetime.
-        * functor tables are not member of this or base class, this class contains 'Function' objects which is a hash-key for looking up a particular functor.
-        * creating multiple objects of CxxMirror and registring the same functor will not increase the functor tables size.
-        * once a functor is registered, no entry will be added to the functor table for the same functor, it acts as a set.
-        * registring the same functor will create duplicate hash-key 'Function' object, which will be ignored if in the same 'CxxMirror' object.
-          if two different 'CxxMirror' objects are created and registering the same functor, the functor table will have only one entry for the functor
-          but two duplicate 'Function' objects will be created, held by respective 'CxxMirror' object.
+        * the inherited data members are freed upon destruction, except the 'functor-containers', they have static lifetime.
+        * 'functor-containers' are not member of this or base class, base only contains 'Function' objects which is a hash-key for looking up a particular functor.
+        * creating multiple objects of CxxMirror and registring the same functor will not increase the 'functor-container' size.
+        * once a functor is registered, no entry will be added to the 'functor-container' for the same functor.
+        * registering the same functor will create duplicate hash-key 'Function' object, which will be ignored if in the same 'CxxMirror' object.
+          if two different 'CxxMirror' objects are created and registering the same functor, the functor-container will have only one entry for the functor
+          but two identical 'Function' objects will be created, held by respective 'CxxMirror' object.
     */  class CxxMirror : public detail::CxxReflection 
         {
         public:

ReflectionTemplateLib/access/inc/Function.hpp

@@ -17,7 +17,7 @@ namespace rtl {
     */  template<class _arg0, class ..._args>
 		inline const bool Function::hasSignature() const
 		{
-			//hasSignatureId() returns the index of functor in functor table, which cannot be '-1'.
+			//hasSignatureId() returns the index of the 'lambda' in functor-container, which cannot be '-1'.
 			return (hasSignatureId(detail::FunctorContainer<_arg0, _args...>::getContainerId()) != -1);
 		}
 
@@ -28,7 +28,7 @@ namespace rtl {
     */  template<>
 		inline const bool Function::hasSignature<void>() const
 		{
-			//hasSignatureId() returns the index of functor in functor table, which cannot be '-1'.
+			//hasSignatureId() returns the index of 'lambda' in functor-container, which cannot be '-1'.
 			return (hasSignatureId(detail::FunctorContainer<>::getContainerId()) != -1);
 		}
 

ReflectionTemplateLib/access/inc/Method.h

@@ -71,10 +71,10 @@ namespace rtl {
     */  class Method : public Function
         {
             //private ctor, called by 'Record' class.
-            Method(const Function& pFunction);
+            explicit Method(const Function& pFunction);
 
             //private ctor, called by 'Record' class.
-            Method(const Function& pFunction, const detail::FunctorId& pFunctorId, const std::string& pFunctorName);
+            explicit Method(const Function& pFunction, const detail::FunctorId& pFunctorId, const std::string& pFunctorName);
 
             //invokes the constructor associated with this 'Method'
             template<class ..._args>

ReflectionTemplateLib/access/inc/Method.hpp

@@ -17,7 +17,7 @@ namespace rtl
         @params: params... (corresponding to functor associated with 'm_method')
         @return: RStatus, indicating success of the reflected call.
         * invokes non-static-member-function functor associated with 'm_method' on object 'm_target'.
-	*/  template<FunctorType _type>
+    */  template<FunctorType _type>
         template<class ..._args>
         inline RStatus MethodInvoker<_type>::call(_args ...params) const noexcept
         {
@@ -27,7 +27,7 @@ namespace rtl
             }
 
             if (m_target.getTypeId() != m_method.getRecordTypeId()) {
-			//if the m_target's type-id & type-id of the 'class/struct' owner of the associated functor(m_method's) do not match.
+            //if the m_target's type-id & type-id of the 'class/struct' owner of the associated functor(m_method's) do not match.
                 return RStatus(Error::InstanceTypeMismatch);
             }
 
@@ -40,7 +40,7 @@ namespace rtl
                 case TypeQ::Const: return m_method.invokeConst(m_target, params...);
             }
 
-			//only an empty 'Instance' will have TypeQ::None.
+            //only an empty 'Instance' will have TypeQ::None.
             return RStatus(Error::EmptyInstance);
         }
 
@@ -60,7 +60,7 @@ namespace rtl
 
 
     namespace access
-	{
+    {
     /*  @method: on()
         @return: MethodInvoker<FunctorType::Static>
         * accepts no arguments for 'target', since associated functor is static-member-functions.
@@ -70,7 +70,10 @@ namespace rtl
         }
 
 
-        inline const MethodInvoker<FunctorType::Method> Method::on(const Instance& pTarget) const
+    /*  @method: on()
+        @return: MethodInvoker<FunctorType::Method>
+        * accepts 'pTarget', which contains the actual object on which the member-function functor associated with 'this' is invoked.
+    */  inline const MethodInvoker<FunctorType::Method> Method::on(const Instance& pTarget) const
         {
             return MethodInvoker<FunctorType::Method>(*this, pTarget);
         }
@@ -88,9 +91,9 @@ namespace rtl
 
 
     /*  @method: invokeStatic()
-	    @params: variable arguments.
-	    @return: RStatus
-	    * with given arguments, calls the static-member-function functor associated with this 'Method'.
+        @params: variable arguments.
+        @return: RStatus
+        * with given arguments, calls the static-member-function functor associated with this 'Method'.
     */  template<class ..._args>
         inline RStatus Method::invokeStatic(_args ...params) const
         {
@@ -173,7 +176,7 @@ namespace rtl
                 return detail::MethodContainer<TypeQ::Mute, _args...>::forwardCall(pTarget.get(), index, params...);
             }
             else {
-                //if no such member-functor is found in non-const MethodContainer, check if such functor is present in const MethodContainer.
+                //if no such member-functor is found in non-const MethodContainer, check if such functor is present in const MethodContainer and call.
                 return invokeConst(pTarget, params...);
             }
         }

ReflectionTemplateLib/access/inc/RStatus.h

@@ -32,7 +32,7 @@ namespace rtl
             //used when the reflected call doesn't have any return value, or in case of call failure.
             RStatus(const Error pCallStatus);
 
-            //used when the reflected call returns a value, always in case of no call failure.
+            //used when the reflected call returns a value, called only in case of no call failure.
             RStatus(const std::any& pRetObj, const std::size_t pTypeId, const TypeQ pQualifier);
 
             GETTER(std::any, Return, m_returnObj)