TypeName.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Array.hpp"
 
#if defined(__clang__) || defined(__GNUC__)
#define CE_META_FUNCTION_NAME __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
#define CE_META_FUNCTION_NAME __FUNCSIG__
#else
       # error Unsupported compiler
#endif
 
namespace CeresEngine {
 
    namespace internal {
 
        template <std::size_t... Idxs>
        consteval auto makeTypeNameArray(StringView str, std::index_sequence<Idxs...>) {
            return std::array{str[Idxs]..., (char)0x00};
        }
 
        template <typename T>
        consteval auto getTypeNameArrayPrefix() {
            constexpr StringView function = CE_META_FUNCTION_NAME;
            return function.find("double") - 6;
        }
 
        template <typename T>
        consteval auto getTypeNameArraySuffix() {
            constexpr StringView function = CE_META_FUNCTION_NAME;
            return function.size() - function.rfind("double") - 6;
        }
 
        template <typename T>
        consteval auto getTypeNameArray() {
            constexpr StringView function = CE_META_FUNCTION_NAME;
 
            constexpr auto start = getTypeNameArrayPrefix<double>();
            constexpr auto end = function.size() - getTypeNameArraySuffix<double>();
 
            static_assert(start < end);
 
            constexpr auto name = function.substr(start, (end - start));
            if constexpr(name.find("class ") == 0) {
                return makeTypeNameArray(name.substr(6), std::make_index_sequence<name.size() - 6>{});
            } else if constexpr(name.find("struct ") == 0) {
                return makeTypeNameArray(name.substr(7), std::make_index_sequence<name.size() - 7>{});
            } else {
                return makeTypeNameArray(name, std::make_index_sequence<name.size()>{});
            }
        }
 
        template<typename T> static inline constexpr auto TypeNameHolder = getTypeNameArray<T>();
 
        template<class T> constexpr StringView getTypeName() {
            constexpr auto& value = TypeNameHolder<T>;
            return StringView{value.data(), value.size() - 1};
        }
    } // namespace internal
 
    // More precise version!
    // C++11 states that initialization of local statics is thread-safe
    // and constructor is called only once. Using __PRETTY_FUNCTION__ hack.
    template<typename T> [[nodiscard]] constexpr StringView getTypeName() { return internal::getTypeName<T>(); }
 
} // namespace CeresEngine