FunctionBase.h

 
#pragma once
 
#include "Refureku/TypeInfo/Entity/Entity.h"
#include "Refureku/TypeInfo/Functions/FunctionParameter.h"
#include "Refureku/TypeInfo/Functions/ICallable.h"
 
namespace rfk
{
    class FunctionBase : public Entity
    {
        public:
            template <typename ReturnType, typename... ArgTypes>
            RFK_NODISCARD bool                                      hasSameSignature()                          const   noexcept;
 
            RFK_NODISCARD REFUREKU_API bool                         hasSameSignature(FunctionBase const& other) const   noexcept;
 
            template <typename... ArgTypes>
            RFK_NODISCARD bool                                      hasSameParameters()                         const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Type const&                  getReturnType()                             const   noexcept;
 
            RFK_NODISCARD REFUREKU_API FunctionParameter const&     getParameterAt(std::size_t index)           const   noexcept;   
 
            RFK_NODISCARD REFUREKU_API std::size_t                  getParametersCount()                        const   noexcept;
 
            RFK_NODISCARD REFUREKU_API ICallable*                   getInternalFunction()                       const   noexcept;
 
            REFUREKU_API FunctionParameter&                         addParameter(char const*    name,
                                                                                 std::size_t    id,
                                                                                 Type const&    type)                   noexcept;
 
            REFUREKU_API void                                       setParametersCapacity(std::size_t capacity)         noexcept;
 
        protected:
            //Forward declaration
            class FunctionBaseImpl;
 
            REFUREKU_INTERNAL FunctionBase(FunctionBaseImpl* implementation)    noexcept;
            REFUREKU_INTERNAL FunctionBase(FunctionBase&&)                      noexcept;
            REFUREKU_INTERNAL ~FunctionBase()                                   noexcept;
 
            RFK_GEN_GET_PIMPL(FunctionBaseImpl, Entity::getPimpl());
 
            template <typename... ArgTypes>
            void    checkParametersCount()  const;
 
            template <typename... ArgTypes>
            void    checkParameterTypes()   const;
 
            template <typename ReturnType>
            void    checkReturnType()       const;
 
        private:
            template <typename ReturnType>
            RFK_NODISCARD bool              hasSameReturnType()                                     const   noexcept;
 
            template <typename... ArgTypes>
            RFK_NODISCARD bool              hasSameParametersCount()                                const   noexcept;
 
            template <std::size_t Rank, typename FirstArgType, typename SecondArgType, typename... OtherArgTypes>
            RFK_NODISCARD bool              hasSameParameterTypes()                                 const   noexcept;
            template <std::size_t Rank, typename LastArgType>
            RFK_NODISCARD bool              hasSameParameterTypes()                                 const   noexcept;
            template <typename... ArgTypes>
            RFK_NODISCARD bool              hasSameParameterTypes()                                 const   noexcept;
 
            template <std::size_t Rank, typename FirstArgType, typename SecondArgType, typename... OtherArgTypes>
            void                            checkParameterTypes()                                   const;
            template <std::size_t Rank, typename LastArgType>
            void                            checkParameterTypes()                                   const;
 
            RFK_NORETURN REFUREKU_API void  throwArgCountMismatchException(std::size_t received)    const;
 
            RFK_NORETURN REFUREKU_API void  throwArgTypeMismatchException(std::size_t paramIndex)   const;
 
            RFK_NORETURN REFUREKU_API void  throwReturnTypeMismatchException()                      const;
    };
 
    #include "Refureku/TypeInfo/Functions/FunctionBase.inl"
}