C++ get_args() #5431

    auto [x,y, text] = get_args<float, float, std::string>(mrb);

template <typename ARG>
constexpr void get_spec(size_t i, ARG, char* data);

template <>
constexpr void get_spec(size_t i, mrb_int, char* data)
{ data[i] = 'i'; }

template <>
constexpr void get_spec(size_t i, mrb_float, char* data)
{ data[i] = 'f'; }

template <>
inline void get_spec(size_t i, const char*, char* data)
{ data[i] = 'z'; }

template <typename T> struct ToMrb { using To = T; };
template <> struct ToMrb<std::string> { using To = const char*; };
template <> struct ToMrb<std::string const&> { using To = const char*; };
template <> struct ToMrb<float> { using To = mrb_float; };
template <> struct ToMrb<int> { using To = mrb_int; };

template <class... ARGS, size_t... A>
auto get_args(
    mrb_state* mrb, std::vector<mrb_value>* restv, std::index_sequence<A...>)
{
    std::tuple<typename ToMrb<ARGS>::To...> input;

    std::array<char, sizeof...(ARGS) + 2> spec;
    spec[sizeof...(ARGS)] = '*';
    spec[sizeof...(ARGS) + 1] = 0;
    (void)std::tuple{(get_spec(A, std::get<A>(input), spec.data()), 0)...};

    mrb_int n = 0;
    mrb_value* rest{};
    mrb_get_args(mrb, spec.data(), &std::get<A>(input)..., &rest, &n);
    if (n > 0) {
        for (int i = 0; i < n; i++) {
            restv->push_back(rest[i]);
        }
    }
    return input;
}

//! Get function args according to type list
//! ex
//!
//! auto [x,y, txt] = get_args<float, float, std::string>(mrb);
//! draw_text(x,y, txt);
//
template <class... ARGS>
auto get_args(mrb_state* mrb)
{
    return get_args<ARGS...>(
        mrb, nullptr, std::make_index_sequence<sizeof...(ARGS)>());
}

template <class... ARGS>
auto get_args(mrb_state* mrb, std::vector<mrb_value>& rest)
{
    return get_args<ARGS...>(
        mrb, &rest, std::make_index_sequence<sizeof...(ARGS)>());
}