Function.h

 
#pragma once
 
#include "Refureku/TypeInfo/Functions/FunctionBase.h"
#include "Refureku/TypeInfo/Functions/EFunctionFlags.h"
#include "Refureku/TypeInfo/Functions/NonMemberFunction.h"
 
namespace rfk
{
    class Function final : public FunctionBase
    {
        public:
            REFUREKU_API Function(char const*       name, 
                                  std::size_t       id,
                                  Type const&       returnType,
                                  ICallable*        internalFunction,
                                  EFunctionFlags    flags)          noexcept;
            Function(Function&&)                                    = delete;
            REFUREKU_API ~Function()                                noexcept;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType                                  invoke(ArgTypes&&... args)          const;
 
            template <typename ReturnType = void, typename... ArgTypes>
            ReturnType                                  checkedInvoke(ArgTypes&&... args)   const;
 
            RFK_NODISCARD REFUREKU_API bool             isInline()                          const   noexcept;
 
            RFK_NODISCARD REFUREKU_API bool             isStatic()                          const   noexcept;
 
            RFK_NODISCARD REFUREKU_API EFunctionFlags   getFlags()                          const   noexcept;
 
        private:
            //Forward declaration
            class FunctionImpl;
 
            RFK_GEN_GET_PIMPL(FunctionImpl, Entity::getPimpl())
 
            template <typename ReturnType, typename... ArgTypes>
            ReturnType  internalInvoke(ArgTypes&&... args)  const;
    };
 
    template <auto FuncPtr>
    Function const* getFunction() noexcept;
 
    REFUREKU_TEMPLATE_API(rfk::Allocator<Function const*>);
    REFUREKU_TEMPLATE_API(rfk::Vector<Function const*, rfk::Allocator<Function const*>>);
 
    #include "Refureku/TypeInfo/Functions/Function.inl"
}