refactored

Author: neeraj31285

ReflectionTemplateLib/access/inc/Record.hpp

@@ -3,7 +3,6 @@
 #include "RStatus.h"
 #include "Method.h"
 #include "Constants.h"
-#include "Constants.hpp"
 #include "Instance.h"
 
 namespace rtl {
@@ -13,12 +12,12 @@ namespace rtl {
 		template<class ..._ctorArgs>
 		inline const std::pair<RStatus, Instance> Record::instance(_ctorArgs ...params) const
 		{
-			const std::string& ctor = getCtorName(m_recordName);
+			const std::string& ctor = CtorName::ctor(m_recordName);
 			const auto& itr = m_methods.find(ctor);
 			if (itr != m_methods.end()) {
 				const RStatus& status = itr->second.invokeCtor(params...);
 				if (status) {
-					const std::string& dctor = getDctorName(m_recordName);
+					const std::string& dctor = CtorName::dctor(m_recordName);
 					return std::make_pair(status, Instance(status.getReturn(), status, *getMethod(dctor)));
 				}
 				return std::make_pair(status, Instance());

ReflectionTemplateLib/access/src/CMakeLists.txt

@@ -11,7 +11,6 @@ set(LOCAL_SOURCES
 
 SET(COMMON_HEADERS
 	"${PROJECT_SOURCE_DIR}/common/Constants.h"
-	"${PROJECT_SOURCE_DIR}/common/Constants.hpp"
 	"${PROJECT_SOURCE_DIR}/common/RTLibInterface.h"
 )
 

ReflectionTemplateLib/access/src/Method.cpp

@@ -1,6 +1,5 @@
 
 #include "Method.h"
-#include "Constants.hpp"
 
 namespace rtl {
 
@@ -18,7 +17,7 @@ namespace rtl {
 
 		Method Method::getDestructorMethod(const Function& pFunction, const detail::FunctorId& pFunctorId)
 		{
-			const std::string dctorStr = getDctorName(pFunction.getRecordName());
+			const std::string dctorStr = CtorName::dctor(pFunction.getRecordName());
 			return Method(pFunction, pFunctorId, dctorStr);
 		}
 	}

ReflectionTemplateLib/access/src/Record.cpp

@@ -4,7 +4,6 @@
 #include "RStatus.h"
 #include "Instance.h"
 #include "Constants.h"
-#include "Constants.hpp"
 #include "Function.hpp"
 
 namespace rtl {
@@ -45,9 +44,9 @@ namespace rtl {
 				return std::make_pair(RStatus(Error::EmptyInstance), Instance());
 			}
 
-			const std::string& dctor = getDctorName(m_recordName);
-			const std::string& copyStr = getCopyCtorName(m_recordName);
-			const std::string& constCopyStr = getConstCopyCtorName(m_recordName);
+			const std::string& dctor = CtorName::dctor(m_recordName);
+			const std::string& copyStr = CtorName::copy(m_recordName);
+			const std::string& constCopyStr = CtorName::constCopy(m_recordName);
 
 			std::optional<Function> destructor = getMethod(dctor);
 			std::optional<Function> constCopyCtor = getMethod(constCopyStr);

ReflectionTemplateLib/builder/CMakeLists.txt

@@ -2,7 +2,6 @@
 
 SET(COMMON_HEADERS
 	"${PROJECT_SOURCE_DIR}/common/Constants.h"
-	"${PROJECT_SOURCE_DIR}/common/Constants.hpp"
 )
 
 SET(LOCAL_HEADERS

ReflectionTemplateLib/builder/inc/ConstructorBuilder.hpp

@@ -2,7 +2,6 @@
 
 #include "Function.h"
 #include "Builder.hpp"
-#include "Constants.hpp"
 #include "ConstructorBuilder.h"
 
 namespace rtl {
@@ -26,15 +25,15 @@ namespace rtl {
 			{
 			default:
 			case FunctorType::Ctor: {
-				const auto& ctorName = getCtorName(m_record);
+				const auto& ctorName = CtorName::ctor(m_record);
 				return Builder<TypeQ::Mute>(m_namespace, m_record, ctorName).build<_recordType, _ctorSignature...>();
 			}
 			case FunctorType::CopyCtor: {
-				const auto& ctorName = getCopyCtorName(m_record);
+				const auto& ctorName = CtorName::copy(m_record);
 				return Builder<TypeQ::Mute>(m_namespace, m_record, ctorName).build<_recordType, _ctorSignature...>();
 			}
 			case FunctorType::CopyCtorConst: {
-				const auto& ctorName = getConstCopyCtorName(m_record);
+				const auto& ctorName = CtorName::constCopy(m_record);
 				return Builder<TypeQ::Mute>(m_namespace, m_record, ctorName).build<_recordType, _ctorSignature...>();
 			}
 			}

ReflectionTemplateLib/common/Constants.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <string>
 #include <type_traits>
 
 namespace rtl {
@@ -61,4 +62,23 @@ namespace rtl {
 
     template<class _type, class _typeB>
     using enable_if_not_same = typename std::enable_if< !std::is_same<_type, _typeB>::value >::type;
+
+    struct CtorName
+    {
+        static const std::string ctor(const std::string& pRecordName) {
+            return (pRecordName + "::" + pRecordName + "()");
+        }
+
+        static const std::string dctor(const std::string& pRecordName) {
+            return (pRecordName + "::~" + pRecordName + "()");
+        }
+
+        static const std::string copy(const std::string& pRecordName) {
+            return (pRecordName + "::" + pRecordName + "(" + pRecordName + "&)");
+        }
+
+        static const std::string constCopy(const std::string& pRecordName) {
+            return (pRecordName + "::" + pRecordName + "(const " + pRecordName + "&)");
+        }
+    };
 }

ReflectionTemplateLib/common/Constants.hpp

@@ -2,7 +2,6 @@
 #include "TypeId.h"
 #include "Record.h"
 #include "Method.h"
-#include "Constants.hpp"
 #include "CxxReflection.h"
 
 namespace rtl {
@@ -54,7 +53,7 @@ namespace rtl {
 				auto& functorIds = pFunction.getFunctorIds();
 				if (functorIds.size() > 1) 
 				{
-					const auto& dctorName = getDctorName(pFunction.getRecordName());
+					const auto& dctorName = CtorName::dctor(pFunction.getRecordName());
 					if (pMethodMap.find(dctorName) == pMethodMap.end()) {
 						access::Method method = access::Method::getDestructorMethod(pFunction, functorIds[1]);
 						pMethodMap.insert(std::make_pair(method.getFunctionName(), method));