TypesUtils.hpp

#pragma once
#include <Core/RaCore.hpp>
#include <Core/Utils/StringUtils.hpp>
 
#ifndef _WIN32
#    include <cxxabi.h>
#    include <memory>
#else
#    include <typeinfo>
#endif
 
#include <regex>
#include <string>
#include <typeindex>
 
namespace Ra {
namespace Core {
namespace Utils {
 
template <typename T>
std::string demangleType() noexcept;
 
template <typename T>
std::string demangleType( const T& ) noexcept;
 
RA_CORE_API std::string demangleType( const std::type_index& typeName ) noexcept;
 
template <typename T>
auto simplifiedDemangledType() noexcept -> std::string;
 
template <typename T>
auto simplifiedDemangledType( const T& ) noexcept -> std::string;
 
RA_CORE_API auto simplifiedDemangledType( const std::type_index& typeName ) noexcept -> std::string;
 
// Check if a type is a container with access to its element type and number
// adapted from https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
namespace detail {
 
using std::begin;
using std::end;
 
template <typename T>
auto is_container_impl( int )
    -> decltype( begin( std::declval<T&>() ) !=
                     end( std::declval<T&>() ), // begin/end and operator !=
                 void(),                        // Handle evil operator ,
                 std::declval<T&>().empty(),
                 std::declval<T&>().size(),
                 ++std::declval<decltype( begin( std::declval<T&>() ) )&>(), // operator ++
                 void( *begin( std::declval<T&>() ) ),                       // operator*
                 std::true_type {} );
 
template <typename T>
std::false_type is_container_impl( ... );
 
} // namespace detail
 
template <typename T>
using is_container = decltype( detail::is_container_impl<T>( 0 ) );
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
namespace TypeInternal {
RA_CORE_API auto makeTypeReadable( const std::string& ) -> std::string;
}
 
template <typename T>
auto simplifiedDemangledType() noexcept -> std::string {
    // don't get why we need a lambda here ?
    // static auto demangled_name = []() {
    //     std::string demangledType =
    //         TypeInternal::makeTypeReadable( Ra::Core::Utils::demangleType<T>() );
    //     return demangledType;
    // }();
    static auto demangled_name =
        TypeInternal::makeTypeReadable( Ra::Core::Utils::demangleType<T>() );
 
    return demangled_name;
}
 
template <typename T>
auto simplifiedDemangledType( const T& ) noexcept -> std::string {
    return simplifiedDemangledType<T>();
}
 
inline auto simplifiedDemangledType( const std::type_index& typeName ) noexcept -> std::string {
    return TypeInternal::makeTypeReadable( Ra::Core::Utils::demangleType( typeName ) );
}
 
// 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;
};
 
inline std::string demangleType( const std::type_index& typeIndex ) noexcept {
    std::string retval;
 
    // On windows (since MSVC 2019), typeid( T ).name() (and then typeIndex.name() returns the
    // demangled name
#ifdef _WIN32
    retval = typeIndex.name();
    // On Linux/macos, use the C++ ABI demangler
#else
    int error  = 0;
    char* name = abi::__cxa_demangle( typeIndex.name(), 0, 0, &error );
    if ( error == 0 ) { retval = name; }
    else {
        // error : -1 --> memory allocation failed
        // error : -2 --> not a valid mangled name
        // error : other --> __cxa_demangle
        retval = std::string( "Type demangler error : " ) + std::to_string( error );
    }
    std::free( name );
#endif
    removeAllInString( retval, "class " );
    removeAllInString( retval, "struct " );
    removeAllInString( retval, "__cdecl" );
    replaceAllInString( retval, "& __ptr64", "&" );
    replaceAllInString( retval, ",", ", " );
    replaceAllInString( retval, " >", ">" );
    replaceAllInString( retval, "__int64", "long" );
    replaceAllInString( retval, "const &", "const&" );
    removeAllInString( retval, "__cxx11::" ); // windows<>gnu inconsistency
    removeAllInString( retval, "__1::" );     // or "::__1" ?
    replaceAllInString( retval, " >", ">" );
 
    // " ,  ,  , ,,"  -> ,
    retval = std::regex_replace( retval, std::regex( R"(\s*,(\s*,)+)" ), "," );
    //"  ," -> ,
    retval = std::regex_replace( retval, std::regex( R"(\s*,)" ), "," );
    // "  , >" -> >
    retval = std::regex_replace( retval, std::regex( R"(\s*,\s*>)" ), ">" );
    // "   " -> " "
    retval = std::regex_replace( retval, std::regex( R"(\s+)" ), " " );
 
    return retval;
}
 
template <typename T>
std::string demangleType() noexcept {
    // once per one type
    static auto demangled_name = demangleType( std::type_index( typeid( T ) ) );
    return demangled_name;
}
 
// calling with instances
template <typename T>
std::string demangleType( const T& ) noexcept {
    return demangleType<T>();
}
 
} // namespace Utils
} // namespace Core
} // namespace Ra