removed custom GETTER macros.

RTLTestRunApp/src/FunctionalityTests/MoveConstructorTests.cpp

@@ -57,7 +57,7 @@ namespace rtl_tests
             // 'Event' has a unique_ptr<Date> and two 'Event' instances exists, So-
             EXPECT_TRUE(date::get_instance_count() == 2);
             {
-                // Cloning a moved-from object ie an empty object;
+                // Deliberatly cloning a moved-from object ie an empty object;
                 auto [err, ret] = calender0.clone<alloc::Stack>();
                 EXPECT_TRUE(err == error::EmptyRObject);
                 ASSERT_TRUE(ret.isEmpty());

ReflectionTemplateLib/rtl/detail/inc/RObjectId.h

@@ -31,8 +31,13 @@ namespace rtl::detail
 
         const std::vector<traits::ConverterPair>* m_converters = nullptr;
 
-        GETTER(traits::uid_t, TypeId, m_typeId)
-        GETTER(EntityKind, ContainedAs, m_containsAs)
+        constexpr const traits::uid_t getTypeId() const {
+            return m_typeId;
+        }
+
+        constexpr const EntityKind getContainedAs() const {
+            return m_containsAs;
+        }
 
         template<class T>
         static constexpr const std::vector<traits::ConverterPair>& getConverters() noexcept

ReflectionTemplateLib/rtl/dispatch/forward_call.h

@@ -68,8 +68,13 @@ namespace rtl::dispatch
             }
         }
 
-        GETTER(error, _init_error, m_init_err)
-        GETTER(traits::uid_t, _record_id, m_record_id)
+        constexpr const error get_init_error() const {
+            return m_init_err;
+        }
+
+        constexpr const traits::uid_t get_record_id() const {
+            return m_record_id;
+        }
 
     private:
 
@@ -81,8 +86,13 @@ namespace rtl::dispatch
         std::vector<lambda_t> m_hopper = {};
         std::vector<const functor*> m_functors = {};
 
-        GETTER_REF(std::vector<lambda_t>, _hopper, m_hopper)
-        GETTER_REF(std::vector<const functor*>, _overloads, m_functors)
+        constexpr std::vector<lambda_t>& get_hopper() {
+            return m_hopper;
+        }
+
+        constexpr std::vector<const functor*>& get_overloads() {
+            return m_functors;
+        }
 
         void set_init_error(error p_err) {
             m_init_err = p_err;
@@ -92,10 +102,10 @@ namespace rtl::dispatch
             m_record_id = p_recid;
         }
 
-        template<detail::member, class ...>
+        template<detail::member, class...>
         friend struct detail::InitFunctionHop;
 
-        template<detail::member, class, class ...>
+        template<detail::member, class, class...>
         friend struct detail::InitMethodHop;
 	};
 }

ReflectionTemplateLib/rtl/dispatch/functor.h

@@ -17,11 +17,25 @@ namespace rtl::dispatch
 {
     struct functor
     {
-        GETTER_BOOL(_void, m_is_void)
-        GETTER_BOOL(_any_arg_ncref, m_is_any_arg_ncref)
-        GETTER(traits::uid_t, _record_id, m_record_id)
-        GETTER(traits::uid_t, _strict_sign_id, m_strict_args_id)
-        GETTER(traits::uid_t, _normal_sign_id, m_normal_args_id)
+        constexpr const bool is_void() const {
+            return m_is_void;
+        }
+
+        constexpr const bool is_any_arg_ncref() const {
+            return m_is_any_arg_ncref;
+        }
+
+        constexpr const traits::uid_t get_record_id() const {
+            return m_record_id;
+        }
+
+        constexpr const traits::uid_t get_strict_sign_id() const {
+            return m_strict_args_id;
+        }
+
+        constexpr const traits::uid_t get_normal_sign_id() const {
+            return m_normal_args_id;
+        }
 
     protected:
 

ReflectionTemplateLib/rtl/inc/Function.h

@@ -48,18 +48,10 @@ namespace rtl
 
         bool hasSignatureId(const traits::uid_t pSignatureId) const;
 
-        GETTER_REF_C(std::vector<type_meta>, Functors, m_functorsMeta)
+        constexpr std::vector<type_meta>& getFunctors() const;
 
     public:
 
-        //simple inlined getters.
-        GETTER(detail::member, MemberKind, m_member_kind);
-        GETTER(traits::uid_t, RecordTypeId, m_recordTypeId);
-
-        GETTER_CREF(std::string, RecordName, m_recordStr);
-        GETTER_CREF(std::string, FunctionName, m_function);
-        GETTER_CREF(std::vector<type_meta>, FunctorsMeta, m_functorsMeta)
-
         Function() = default;
         Function(Function&&) = default;
         Function(const Function&) = default;
@@ -72,7 +64,45 @@ namespace rtl
         template<class ..._args>
         constexpr bool hasSignature() const;
 
+        constexpr const std::string& getRecordName() const;
+
+        constexpr const std::string& getFunctionName() const;
+
+        constexpr const detail::member getMemberKind() const;
+
+        constexpr const traits::uid_t getRecordTypeId() const;
+
+        constexpr const std::vector<type_meta>& getFunctorsMeta() const;
+
         friend detail::CxxReflection;
         friend builder::ReflectionBuilder;
     };
+}
+
+
+namespace rtl
+{
+    constexpr std::vector<type_meta>& Function::getFunctors() const {
+        return m_functorsMeta;
+    }
+
+    constexpr const detail::member Function::getMemberKind() const {
+        return m_member_kind;
+    };
+
+    constexpr const traits::uid_t Function::getRecordTypeId() const {
+        return m_recordTypeId;
+    };
+
+    constexpr const std::string& Function::getRecordName() const {
+        return m_recordStr;
+    };
+
+    constexpr const std::string& Function::getFunctionName() const {
+        return m_function;
+    };
+
+    constexpr const std::vector<type_meta>& Function::getFunctorsMeta() const {
+        return m_functorsMeta;
+    }
 }

ReflectionTemplateLib/rtl/inc/Function.hpp

@@ -17,7 +17,7 @@
 namespace rtl 
 {
     template<class ...signatureT>
-    inline constexpr const detail::InitFunctionHop<detail::member::None, signatureT...> Function::argsT() const
+    constexpr const detail::InitFunctionHop<detail::member::None, signatureT...> Function::argsT() const
     {
         return detail::HopBuilder<detail::member::None>{ m_functorsMeta }.argsT<signatureT...>();
     }
@@ -29,15 +29,14 @@ namespace rtl
     * a single 'Function' object can be associated with multiple overloads of same function.
     * the set of arguments passed is checked against all registered overloads, returns true if matched with any one.
 */  template<class ..._args>
-    inline constexpr bool Function::hasSignature() const
+    constexpr bool Function::hasSignature() const
     {
         return hasSignatureId(traits::uid<traits::strict_sign_id_t<_args...>>::value);
     }
 
 
     inline bool Function::hasSignatureId(const traits::uid_t pSignatureId) const
     {
-        //simple linear-search, efficient for small set of elements.
         for (const auto& fnMeta : m_functorsMeta) {
             if (fnMeta.get_strict_args_id() == pSignatureId) [[likely]] {
                 return true;

ReflectionTemplateLib/rtl/inc/RObject.h

@@ -45,7 +45,7 @@ namespace rtl
         template<class T>
         std::optional<rtl::view<T>> performConversion(const std::size_t pIndex) const;
 
-        GETTER_BOOL(ConstCastSafe, m_objectId.m_isConstCastSafe)
+        constexpr const bool isConstCastSafe() const;
 
     public:
 
@@ -56,11 +56,13 @@ namespace rtl
         RObject(RObject&&) noexcept;
         RObject& operator=(RObject&&) noexcept;
 
-        GETTER_BOOL(Empty, (m_object == std::nullopt || !m_object->has_value()))
-        GETTER_BOOL(OnHeap, (m_objectId.m_allocatedOn == alloc::Heap))
-        GETTER_BOOL(AllocatedByRtl, (m_objectId.m_allocatedOn == alloc::Heap))
-        GETTER(std::size_t, TypeId, m_objectId.m_typeId)
-        GETTER_CREF(std::optional<std::any>, Any, m_object)
+        constexpr const bool isEmpty() const;
+
+        constexpr const bool isOnHeap() const;
+
+        constexpr const bool isAllocatedByRtl() const;
+
+        constexpr const std::size_t getTypeId() const;
 
         template <class _asType>
         bool canViewAs() const;
@@ -99,9 +101,42 @@ namespace rtl
         template<class , class, class ...>
         friend struct method;
     };
+}
+
 
+namespace rtl
+{
     struct [[nodiscard]] Return {
         error err;
         RObject robject;
     };
+}
+
+
+namespace rtl
+{
+    constexpr const bool RObject::isConstCastSafe() const
+    {
+        return m_objectId.m_isConstCastSafe;
+    }
+
+    constexpr const bool RObject::isEmpty() const
+    {
+        return (m_object == std::nullopt || !m_object->has_value());
+    }
+
+    constexpr const bool RObject::isOnHeap() const
+    {
+        return (m_objectId.m_allocatedOn == alloc::Heap);
+    }
+
+    constexpr const bool RObject::isAllocatedByRtl() const
+    {
+        return (m_objectId.m_allocatedOn == alloc::Heap);
+    }
+
+    constexpr const std::size_t RObject::getTypeId() const
+    {
+        return m_objectId.m_typeId;
+    }
 }

ReflectionTemplateLib/rtl/inc/Record.h

@@ -39,7 +39,7 @@ namespace rtl
             , m_recordName(pRecordName)
         { }
 
-        GETTER_REF_C(MethodMap, FunctionsMap, m_methods)
+        constexpr MethodMap& getFunctionsMap() const;
 
     public:
 
@@ -49,8 +49,8 @@ namespace rtl
         Record& operator=(Record&&) = default;
         Record& operator=(const Record&) = default;
 
-        GETTER_CREF(MethodMap, MethodMap, m_methods)
-        GETTER_CREF(std::string, RecordName, m_recordName)
+        constexpr const MethodMap& getMethodMap() const;
+        constexpr const std::string& getRecordName() const;
 
         template<class ...args_t>
         constructor<args_t...> ctorT() const;
@@ -71,4 +71,20 @@ namespace rtl
         //only class which can create objects of this class & manipulates 'm_methods'.
         friend class detail::CxxReflection;
     };
+}
+
+
+namespace rtl
+{
+    constexpr Record::MethodMap& Record::getFunctionsMap() const {
+        return m_methods;
+    }
+
+    constexpr const Record::MethodMap& Record::getMethodMap() const {
+        return m_methods;
+    }
+
+    constexpr const std::string& Record::getRecordName() const {
+        return m_recordName;
+    }
 }

ReflectionTemplateLib/rtl/inc/type_meta.h

@@ -27,21 +27,20 @@ namespace rtl
         type_meta& operator=(type_meta&&) = default;
         type_meta& operator=(const type_meta&) = default;
 
-        GETTER_BOOL(_empty, !m_functor.has_value())
-        GETTER_BOOL(_void, m_functor->get().m_is_void)
-        GETTER_BOOL(_any_arg_ncref, m_functor->get().m_is_any_arg_ncref)
+        constexpr const bool is_void() const;
+        constexpr const bool is_empty() const;
+        constexpr const bool is_any_arg_ncref() const;
 
-        GETTER(std::string, _signature_str, m_functor->get().m_signature_str)
-        GETTER_CREF(std::vector<std::size_t>, _args_id_arr, m_functor->get().m_args_type_ids)
+        constexpr const std::string get_signature_str() const;
+        constexpr const std::vector<std::size_t>& get_args_id_arr() const;
 
-        GETTER(traits::uid_t, _return_id, m_functor->get().m_return_id)
-        GETTER(traits::uid_t, _record_id, m_functor->get().m_record_id)
-        GETTER(traits::uid_t, _normal_args_id, m_functor->get().m_normal_args_id)
-        GETTER(traits::uid_t, _strict_args_id, m_functor->get().m_strict_args_id)
+        constexpr const detail::member get_member_kind() const;
+        constexpr const dispatch::functor& get_functor() const;
 
-        GETTER(detail::member, _member_kind, m_functor->get().m_member_kind)
-
-        GETTER_CREF(dispatch::functor, _functor, m_functor->get())
+        constexpr const traits::uid_t get_record_id() const;
+        constexpr const traits::uid_t get_return_id() const;
+        constexpr const traits::uid_t get_normal_args_id() const;
+        constexpr const traits::uid_t get_strict_args_id() const;
 
         template<class return_t, class ...signature_t>
         static type_meta add_function(return_t(*p_fptr)(signature_t...),
@@ -72,4 +71,52 @@ namespace rtl
 
         friend detail::CxxReflection;
     };
+}
+
+
+namespace rtl
+{
+    constexpr const bool type_meta::is_empty() const {
+        return !m_functor.has_value();
+    }
+
+    constexpr const bool type_meta::is_void() const {
+        return m_functor->get().m_is_void;
+    }
+
+    constexpr const bool type_meta::is_any_arg_ncref() const {
+        return m_functor->get().m_is_any_arg_ncref;
+    }
+
+    constexpr const std::string type_meta::get_signature_str() const {
+        return m_functor->get().m_signature_str;
+    }
+
+    constexpr const traits::uid_t type_meta::get_return_id() const {
+        return m_functor->get().m_return_id;
+    }
+
+    constexpr const traits::uid_t type_meta::get_record_id() const {
+        return m_functor->get().m_record_id;
+    }
+
+    constexpr const traits::uid_t type_meta::get_normal_args_id() const {
+        return m_functor->get().m_normal_args_id;
+    }
+
+    constexpr const traits::uid_t type_meta::get_strict_args_id() const {
+        return m_functor->get().m_strict_args_id;
+    }
+
+    constexpr const detail::member type_meta::get_member_kind() const {
+        return m_functor->get().m_member_kind;
+    }
+
+    constexpr const dispatch::functor& type_meta::get_functor() const {
+        return m_functor->get();
+    }
+
+    constexpr const std::vector<std::size_t>& type_meta::get_args_id_arr() const {
+        return m_functor->get().m_args_type_ids;
+    }
 }