TypesUtils.hpp

#pragma once
 
#include <Core/CoreMacros.hpp>
 
#ifndef _WIN32
#    include <cxxabi.h>
#    include <memory>
#else
#    include <typeinfo>
#endif
 
#include <string>
 
#include <Core/Utils/StringUtils.hpp>
 
namespace Ra {
namespace Core {
namespace Utils {
 
template <typename T>
const char* demangleType() noexcept;
 
template <typename T>
const char* demangleType( const T& ) noexcept;
 
// TypeList taken and adapted from
// https://github.com/AcademySoftwareFoundation/openvdb/blob/master/openvdb/openvdb/TypeList.h
// Only took small part of TypeList utilities
 
// forward declarations
template <typename... Ts>
struct TypeList;
 
namespace TypeListInternal {
 
template <typename ListT, typename... Ts>
struct TSAppendImpl;
 
template <typename... Ts, typename... OtherTs>
struct TSAppendImpl<TypeList<Ts...>, OtherTs...> {
    using type = TypeList<Ts..., OtherTs...>;
};
 
template <typename... Ts, typename... OtherTs>
struct TSAppendImpl<TypeList<Ts...>, TypeList<OtherTs...>> {
    using type = TypeList<Ts..., OtherTs...>;
};
 
} // namespace TypeListInternal
 
template <typename... Ts>
struct TypeList {
    using Self = TypeList;
    static constexpr size_t Size = sizeof...( Ts );
 
    template <typename... TypesToAppend>
    using Append = typename TypeListInternal::TSAppendImpl<Self, TypesToAppend...>::type;
};
 
#ifdef _WIN32
// On windows (since MSVC 2019), typeid( T ).name() returns the demangled name
template <typename T>
const char* demangleType() noexcept {
    static auto demangled_name = []() {
        std::string retval { typeid( T ).name() };
        removeAllInString( retval, "class " );
        removeAllInString( retval, "struct " );
        replaceAllInString( retval, ",", ", " );
        replaceAllInString( retval, "> >", ">>" );
        return retval;
    }();
 
    return demangled_name.data();
}
#else
template <typename T>
const char* demangleType() noexcept {
    // once per one type
    static auto demangled_name = []() {
        int error = 0;
        std::string retval;
        char* name = abi::__cxa_demangle( typeid( T ).name(), 0, 0, &error );
 
        switch ( error ) {
        case 0:
            retval = name;
            break;
        case -1:
            retval = "memory allocation failed";
            break;
        case -2:
            retval = "not a valid mangled name";
            break;
        default:
            retval = "__cxa_demangle failed";
            break;
        }
        std::free( name );
        removeAllInString( retval, "__1::" ); // or "::__1" ?
        replaceAllInString( retval, "> >", ">>" );
        return retval;
    }();
 
    return demangled_name.data();
}
#endif
// calling with instances
template <typename T>
const char* demangleType( const T& ) noexcept {
    return demangleType<T>();
}
 
} // namespace Utils
} // namespace Core
} // namespace Ra