CodeGenerationHelpers.h

 
#pragma once
 
#include <array>
#include <cstddef>  //std::size_t, std::ptrdiff_t
 
#include "Refureku/Config.h"
#include "Refureku/Misc/TypeTraitsMacros.h"
#include "Refureku/TypeInfo/Archetypes/GetArchetype.h"
#include "Refureku/TypeInfo/Archetypes/Struct.h"
#include "Refureku/Misc/SharedPtr.h"
 
#ifndef _RFK_UNPACK_IF_NOT_PARSING
 
//This macro "KODGEN_PARSING" must match the name defined by the kodgen parser when parsing source files
//It is used by the generated code to hide some portions of code to the parser
#ifdef KODGEN_PARSING
#define RFK_UNPACK_IF_NOT_PARSING(...)
#else
#define RFK_UNPACK_IF_NOT_PARSING(...) __VA_ARGS__
#endif
 
#endif
 
namespace rfk::internal
{
    RFK_GENERATE_IMPLEMENTS_TEMPLATE1_METHOD_TRAITS(_rfk_registerChildClass);
 
    class CodeGenerationHelpers
    {
        public:
            CodeGenerationHelpers()     = delete;
            ~CodeGenerationHelpers()    = delete;
 
            template <typename ParentClass, typename ChildClass>
            static constexpr void                           registerChildClass(rfk::Struct& childClass) noexcept;
 
            template <typename Derived, typename Base>
            RFK_NODISCARD static constexpr std::ptrdiff_t   computeClassPointerOffset()                 noexcept;
 
            template <typename ClassType>
            RFK_NODISCARD static std::size_t                getReflectedFieldsCount()                   noexcept;
 
            template <typename ClassType>
            RFK_NODISCARD static std::size_t                getReflectedStaticFieldsCount()             noexcept;
 
#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ <= 9
            //Handle pre GCC 9 internal compiler error when using type traits in noexcept
            template <typename T>
            RFK_NODISCARD static rfk::SharedPtr<T>  defaultSharedInstantiator();
#else
            template <typename T>
            RFK_NODISCARD static rfk::SharedPtr<T>  defaultSharedInstantiator() noexcept(!std::is_default_constructible_v<T> || std::is_nothrow_constructible_v<T>);
#endif
 
#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ <= 9
            //Handle pre GCC 9 internal compiler error when using type traits in noexcept
            template <typename T>
            RFK_NODISCARD static rfk::UniquePtr<T>  defaultUniqueInstantiator();
#else
            template <typename T>
            RFK_NODISCARD static rfk::UniquePtr<T>  defaultUniqueInstantiator() noexcept(!std::is_default_constructible_v<T> || std::is_nothrow_constructible_v<T>);
#endif
    };
 
    template <auto>
    struct ForceGenerateSymbol
    {
    };
 
    struct RawTypenameFormat
    {
        std::size_t leadingCharsCount   = 0u;
 
        std::size_t trailingCharsCount  = 0u;
    };
 
    template <typename T>
    static constexpr auto const& getRawTypename() noexcept
    {
__RFK_DISABLE_WARNING_PUSH
__RFK_DISABLE_WARNING_LANGUAGE_EXTENSION_TOKEN
 
#ifdef _MSC_VER
        return __FUNCSIG__;
#else
        return __PRETTY_FUNCTION__;
#endif
 
__RFK_DISABLE_WARNING_POP
    }
 
    static constexpr bool getCompilerRawTypenameFormat(RawTypenameFormat* out_format) noexcept
    {
        constexpr auto const& rawTypename = getRawTypename<char>();
 
        for (std::size_t i = 0u;; i++)
        {
            //Detect the "int" chars in the raw type name
            if (rawTypename[i] == 'c' && rawTypename[i+1] == 'h' && rawTypename[i+2] == 'a' && rawTypename[i+3] == 'r')
            {
                if (out_format != nullptr)
                {
                    out_format->leadingCharsCount = i;
                    out_format->trailingCharsCount = sizeof(rawTypename) - i - 4 - 1; // 4 to consume the "char" part, 1 for the string null terminator.
                }
 
                return true;
            }
        }
 
        return false;
    }
 
    inline static constexpr RawTypenameFormat typenameFormat = []
    {
        //The below line is not supported in g++8, so drop it
        //static_assert(getCompilerRawTypenameFormat(nullptr), "Unable to figure out how to generate type names on this compiler.");
            
        RawTypenameFormat format;
        getCompilerRawTypenameFormat(&format);
 
        return format;
    }();
        
    template <typename T>
    constexpr auto getTypenameAsArray() noexcept
    {
        constexpr std::size_t               typenameLength = sizeof(getRawTypename<T>()) - typenameFormat.leadingCharsCount - typenameFormat.trailingCharsCount;
        std::array<char, typenameLength>    typename_{};
 
        for (std::size_t i = 0; i < typenameLength - 1; i++)
        {
            typename_[i] = getRawTypename<T>()[i + typenameFormat.leadingCharsCount];
        }
 
        return typename_;
    }
        
    template <typename T>
    char const* getTypename() noexcept
    {
        static constexpr auto name = getTypenameAsArray<T>();
        
        return name.data();
    }
 
    #include "Refureku/Misc/CodeGenerationHelpers.inl"
}