types.h

Go to the documentation of this file.

 
#pragma once
 
#include "./concepts.h"
#include "./types/base.h"
 
#include <string>
 
#ifdef EMLABCPP_USE_DEMANGLING
#include <cxxabi.h>
#endif
 
namespace emlabcpp
{
 
 
template < typename T >
constexpr bool has_static_size_v = static_sized< T >;
 
 
template < typename Container, typename UnaryCallable >
struct mapped;
 
template < gettable_container Container, typename UnaryCallable >
requires( !range_container< Container > )
struct mapped< Container, UnaryCallable >
{
        using type = decltype( std::declval< UnaryCallable >()(
            std::get< 0 >( std::declval< Container >() ) ) );
};
 
template < range_container Container, typename UnaryCallable >
struct mapped< Container, UnaryCallable >
{
        using type = decltype( std::declval< UnaryCallable >()(
            *std::begin( std::declval< Container >() ) ) );
};
 
template < typename Container, typename UnaryCallable >
using mapped_t = typename mapped< Container, UnaryCallable >::type;
 
template < auto V >
struct tag
{
        using value_type = decltype( V );
 
        static constexpr value_type value = V;
 
        friend constexpr auto operator<=>( tag const&, tag const& ) = default;
};
 
#ifdef EMLABCPP_USE_OSTREAM
template < auto ID >
std::ostream& operator<<( std::ostream& os, tag< ID > )
{
        return os << ID;
}
#endif
 
 
template < typename T >
auto pretty_type_name()
{
#ifdef EMLABCPP_USE_DEMANGLING
        std::string res;
        int         tmp   = 0;
        char* const dname = abi::__cxa_demangle( typeid( T ).name(), nullptr, nullptr, &tmp );
        res               = dname;
        // NOLINTNEXTLINE
        free( dname );
#elif defined EMLABCPP_USE_TYPEID
        std::string_view const res = typeid( T ).name();
#else
        std::string_view const res = "type names not supported";
#endif
        return res;
}
 
 
template < std::size_t >
struct select_utype;
 
template < std::size_t N >
requires( sizeof( uint8_t ) == N )
struct select_utype< N >
{
        using type = uint8_t;
};
 
template < std::size_t N >
requires( sizeof( uint16_t ) == N )
struct select_utype< N >
{
        using type = uint16_t;
};
 
template < std::size_t N >
requires( sizeof( uint32_t ) == N )
struct select_utype< N >
{
        using type = uint32_t;
};
 
template < std::size_t N >
requires( sizeof( uint64_t ) == N )
struct select_utype< N >
{
        using type = uint64_t;
};
 
template < std::size_t N >
using select_utype_t = typename select_utype< N >::type;
 
 
template < typename, template < typename > class >
struct type_map;
 
template < typename... Ts, template < typename > class Fun >
struct type_map< std::tuple< Ts... >, Fun >
{
        using type = std::tuple< Fun< Ts >... >;
};
 
template < typename T, template < typename > class Fun >
using type_map_t = typename type_map< T, Fun >::type;
 
 
template < typename T >
struct type_tag
{
        using type = T;
};
 
 
template < typename T, typename Variant >
struct index_of;
 
template < typename T, typename... Ts >
struct index_of< T, std::variant< Ts... > >
{
        static constexpr std::size_t value =
            std::variant< type_tag< Ts >... >( type_tag< T >() ).index();
        // got the tip for this from:
        // https://stackoverflow.com/questions/52303316/get-index-by-type-in-stdvariant
};
 
template < typename T, typename Variant >
using index_of_v = index_of< T, Variant >::value;
 
}  // namespace emlabcpp