named_tuple.hpp

#ifndef NAMED_TUPLE_HPP
#define NAMED_TUPLE_HPP

#include <iostream>
#include <string_view>
#include <tuple>
#include <type_traits>

namespace util {
namespace type {

template <auto Size>
struct fixed_string {
    char                  data[Size + 1]{};
    static constexpr auto size = Size;
    constexpr explicit(false) fixed_string(const char* str) { std::copy_n(str, Size + 1, data); }
    constexpr explicit(false) operator std::string_view() const { return {data, Size}; }
};

template <auto Size>
fixed_string(const char (&)[Size]) -> fixed_string<Size - 1>;

template <auto...>
struct arg {
    template <class T>
    constexpr auto operator=(const T& t) const {
        return std::pair<arg, T>{*this, t};
    }
};

template <fixed_string Str>
constexpr auto operator""_t() {
    return []<auto... Ns>(std::index_sequence<Ns...>) {
        return arg<Str.data[Ns]...>{};
    }(std::make_index_sequence<Str.size>{});
}

template <class... Ts>
struct namedtuple : std::tuple<Ts...> {
    using std::tuple<Ts...>::tuple;

    template <class T>
    constexpr decltype(auto) operator[](const T) const
        requires (not std::is_void_v<boost::mp11::mp_map_find<boost::mp11::mp_list<Ts...>, T>>)
    {
        using type = boost::mp11::mp_map_find<boost::mp11::mp_list<Ts...>, T>;
        return std::get<type>(*this).second;
    }

    template <class T>
    constexpr auto& operator[](const T)
        requires (not std::is_void_v<boost::mp11::mp_map_find<boost::mp11::mp_list<Ts...>, T>>)
    {
        using type = boost::mp11::mp_map_find<boost::mp11::mp_list<Ts...>, T>;
        return std::get<type>(*this).second;
    }
};
template <class... Ts>
namedtuple(Ts&&...) -> namedtuple<Ts...>;

} // namespace type
} // namespace util

#endif // !NAMED_TUPLE_HPP