VariantHelpers.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_VARIANTHELPERS_HPP
#define ECHOMAP_VARIANTHELPERS_HPP
 
#include <stdexcept>
#include <utility>
#include <variant>
 
namespace echomap::variant_helpers
{

template <typename T, typename Variant> struct IsVariantAlternative : std::false_type
{};

template <typename T, typename... Alternatives>
struct IsVariantAlternative<T, std::variant<Alternatives...>>
    : std::bool_constant<(std::same_as<std::remove_cvref_t<T>, Alternatives> || ...)>
{};

template <typename T, typename Variant>
inline constexpr bool is_variant_alternative_v =
        IsVariantAlternative<std::remove_cvref_t<T>, std::remove_cvref_t<Variant>>::value;

template <typename T, typename Variant>
concept VariantAlternative = is_variant_alternative_v<T, Variant>;

template <class... Ts> struct Overloaded : Ts...
{
    using Ts::operator()...;
};

template <
        class Variant,
        class NameGetter,
        std::size_t... indices>
consteval auto make_variant_name_array(
        std::index_sequence<indices...> sequence
)
{
    std::ignore = sequence;
    return std::array<std::string_view, sizeof...(indices)>{
            NameGetter::template get<std::variant_alternative_t<indices, Variant>>()...
    };
}

template <class Variant, class NameGetter>
inline constexpr auto variant_name_array =
        make_variant_name_array<Variant, NameGetter>(std::make_index_sequence<std::variant_size_v<Variant>>{});

template <
        class Variant,
        std::size_t index>
constexpr Variant make_variant_alternative()
{
    return Variant{std::in_place_index<index>};
}

template <
        class Variant,
        std::size_t... indices>
consteval auto make_variant_factory_array(
        std::index_sequence<indices...> sequence
)
{
    std::ignore = sequence;
    using Factory = Variant (*)();
 
    return std::array<Factory, sizeof...(indices)>{&make_variant_alternative<Variant, indices>...};
}

template <class Variant>
Variant variant_from_index(
        const std::size_t index
)
{
    static constexpr auto factories =
            make_variant_factory_array<Variant>(std::make_index_sequence<std::variant_size_v<Variant>>{});
 
    if (index >= factories.size())
        throw std::out_of_range("Invalid variant index.");
 
    return factories[index]();
}
 
} // namespace echomap::variant_helpers
 
#endif // ECHOMAP_VARIANTHELPERS_HPP