Method.h

 
#pragma once
 
#include <type_traits>  //std::enable_if_v, std::is_const_v
#include <cassert>
 
#include "Refureku/TypeInfo/Cast.h"
#include "Refureku/TypeInfo/MethodFieldHelpers.h"
#include "Refureku/TypeInfo/Archetypes/Struct.h"
#include "Refureku/TypeInfo/Functions/MethodBase.h"
#include "Refureku/TypeInfo/Functions/MemberFunction.h"
#include "Refureku/Misc/CopyConstness.h"
#include "Refureku/Exceptions/InvalidArchetype.h"
 
namespace rfk
{
    class Method final : public MethodBase
    {
        public:
            REFUREKU_INTERNAL Method(char const*        name,
                                        std::size_t     id,
                                        Type const&     returnType,
                                        ICallable*      internalMethod,
                                        EMethodFlags    flags,
                                        Entity const*   outerEntity)    noexcept;
            REFUREKU_INTERNAL Method(Method&&)                          noexcept;
            REFUREKU_INTERNAL ~Method()                                 noexcept;
 
            template <typename ReturnType = void, typename CallerType, typename... ArgTypes, typename = internal::IsAdjustableInstance<CallerType>>
            ReturnType          invoke(CallerType& caller, ArgTypes&&... args)              const;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType          invokeUnsafe(void* caller, ArgTypes&&... args)              const;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType          invokeUnsafe(void const* caller, ArgTypes&&... args)        const;
 
            template <typename ReturnType = void, typename CallerType, typename... ArgTypes, typename = internal::IsAdjustableInstance<CallerType>>
            ReturnType          checkedInvoke(CallerType& caller, ArgTypes&&... args)       const;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType          checkedInvokeUnsafe(void* caller, ArgTypes&&... args)       const;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType          checkedInvokeUnsafe(void const* caller, ArgTypes&&... args) const;
 
            REFUREKU_API void   inheritBaseMethodProperties()                                       noexcept;
 
        private:
            //Forward declaration
            class MethodImpl;
 
            template <typename FunctionPrototype>
            class MemberFunctionSafeCallWrapper;
 
            template <typename ReturnType, typename... ArgTypes>
            class MemberFunctionSafeCallWrapper<ReturnType(ArgTypes...)>
            {
                private:
                    template <typename T>
                    using PointerToMemberMethod = ReturnType (T::*)(ArgTypes...);
 
                public:
                    MemberFunctionSafeCallWrapper() = delete;
 
                    template <typename T, typename = std::enable_if_t<std::is_same_v<T, void> || std::is_same_v<T, void const>>>
                    static ReturnType invoke(ICallable const&   memberFunction,
                                             T*                 caller,
                                             ArgTypes&&...      args);
            };
 
            template <typename ReturnType, typename... ArgTypes>
            ReturnType                      internalInvoke(void*         caller,
                                                           ArgTypes&&... args)                                  const;
            template <typename ReturnType, typename... ArgTypes>
            ReturnType                      internalInvoke(void const*   caller,
                                                           ArgTypes&&... args)                                  const;
 
            template <typename CallerType>
            RFK_NODISCARD CallerType*       adjustCallerPointerAddress(CallerType* caller)                      const;
 
            RFK_NORETURN REFUREKU_API void  throwConstViolationException()                                      const;
    };
 
    REFUREKU_TEMPLATE_API(rfk::Allocator<Method const*>);
    REFUREKU_TEMPLATE_API(rfk::Vector<Method const*, rfk::Allocator<Method const*>>);
 
    #include "Refureku/TypeInfo/Functions/Method.inl"
}