7

我有一些变体using V = std::variant<A, B, C>和原型的功能V parse(const json&)。该函数应该尝试解析所有类型（例如A, B, then C）直到第一次成功（并且应该隐式地解析，因为及时会有很多类型）。

如何实现这种东西？

我们可能想办法使用std::variant_size。

这是接近我需要的东西。

我的解决方案是明确列出所有类型的解析器。

V parse(const json& i_j)
{
using Parser = std::function<MaybeV(const json&)>;
static const auto ps = std::vector<Parser>{
  [](const auto& j)->MaybeV{return j.get<std::optional<A>>;},
  [](const auto& j)->MaybeV{return j.get<std::optional<B>>;},
  [](const auto& j)->MaybeV{return j.get<std::optional<C>>;}
};
for (const auto& p : ps)
  if (auto opt_result = p(i_j))
    return std::move(*opt_result);
throw ParseError("Can't parse");
}

然而，它肯定会被简化，因为 lambdas 仅在类型上有所不同，而我真正需要的是迭代std::variant.

4

2 回答 2

7

您希望编译时间整数从 0 到变体的大小减 1，并可能提前退出迭代它们。

有很多方法可以获得编译时间整数。我最喜欢的两个是生成一个整数常量元组，或者使用一个整数常量参数包调用一个延续。

取整数常量的元组版本，您可以使用“每个元组”依次访问每个元组。

template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index{};

template<std::size_t...Is>
constexpr std::tuple< index_t<Is>... > make_indexes(std::index_sequence<Is...>){
  return std::make_tuple(index<Is>...);
}
template<std::size_t N>
constexpr auto indexing_tuple = make_indexes(std::make_index_sequence<N>{});

从你所说的变体大小。从那里你调用一个 tuple_foreach。

如果解析成功并且尚未解析，则 tuple_foreach 将放置可选的返回值。

V parse(const json& j)
{
  auto indexes = indexing_tuple<tuple_size_v<V>>;
  std::optional<V> retval;
  tuple_foreach(indexes, [&](auto I){ // I is compile time integer
    if(retval) return;
    auto p = j.get<tuple_alternative_t<I>>();
    if(p) retval.emplace(std::move(*p));
  });
  if(!retval) throw ParseError("Can't parse");
  return std::move(*retval);
}

tuple_foreach可以在互联网上找到，但为了完整性：

template<std::size_t...Is, class T, class F>
auto tuple_foreach( std::index_sequence<Is...>, T&& tup, F&& f ) {
  ( f( std::get<Is>( std::forward<T>(tup) ) ), ... );
}
template<class T, class F>
auto tuple_foreach( T&& tup, F&& f ) {
  auto indexes = std::make_index_sequence< std::tuple_size_v< std::decay_t<T> > >{};
  return tuple_foreach( indexes, std::forward<T>(tup), std::forward<F>(f) );
}

应该在中做到这一点。

于 2019-08-24T23:26:44.067 回答
4

可以使用限制模板实例化从0to递归处理类型：std::variant_size_vif-constexpr

#include <variant>
#include <optional>
#include <cstddef>
#include <utility>

using V = std::variant<A, B, C>;

template <std::size_t I = 0>
V parse(const json& j)
{
    if constexpr (I < std::variant_size_v<V>)
    {
        auto result = j.get<std::optional<std::variant_alternative_t<I, V>>>();

        return result ? std::move(*result) : parse<I + 1>(j);
    }
    throw ParseError("Can't parse");
}

演示

于 2019-08-25T06:46:39.163 回答