Разделить заданный тип std :: option по заданным критериям - PullRequest
Новая
       43

Разделить заданный тип std :: option по заданным критериям

20 голосов
/ 04 марта 2020

Как с помощью данного варианта варианта 

using V = std::variant<bool, char, std::string, int, float, double, std::vector<int>>;

объявить два варианта типа 

using V1 = std::variant<bool, char, int, float, double>;
using V2 = std::variant<std::string, std::vector<int>>;

, где V1 включает все арифметические c типы из V и V2 включает все неарифметические c типы из V?

V может быть параметром класса шаблона, например: 

template <class V>
struct TheAnswer
{
    using V1 = ?;
    using V2 = ?;
};

в целом критерии может быть constexpr переменной, например: 

template <class T>
constexpr bool filter;

Ответы [ 3 ]

14 голосов
/ 04 марта 2020

С Boost.Mp11 , это короткий однострочный (как всегда): 

using V1 = mp_filter<std::is_arithmetic, V>;
using V2 = mp_remove_if<V, std::is_arithmetic>;

Вы также можете использовать: 

using V1 = mp_copy_if<V, std::is_arithmetic>;

для сделайте еще две симметрии c.

В качестве альтернативы, 

using P = mp_partition<V, std::is_arithmetic>;
using V1 = mp_first<P>;
using V2 = mp_second<P>;
6 голосов
/ 04 марта 2020

Если по какой-либо причине вы не хотите использовать короткий и разумный ответ Барри, вот тот, который не является ни одним (спасибо @ xskxzr за удаление неуклюжей специализации "bootstrap" и @ max66 за предупреждение о пустом варианте углового дела): 

namespace detail {
    template <class V>
    struct convert_empty_variant {
        using type = V;
    };

    template <>
    struct convert_empty_variant<std::variant<>> {
        using type = std::variant<std::monostate>;
    };

    template <class V>
    using convert_empty_variant_t = typename convert_empty_variant<V>::type;

    template <class V1, class V2, template <class> class Predicate, class V>
    struct split_variant;

    template <class V1, class V2, template <class> class Predicate>
    struct split_variant<V1, V2, Predicate, std::variant<>> {
        using matching = convert_empty_variant_t<V1>;
        using non_matching = convert_empty_variant_t<V2>;
    };

    template <class... V1s, class... V2s, template <class> class Predicate, class Head, class... Tail>
    struct split_variant<std::variant<V1s...>, std::variant<V2s...>, Predicate, std::variant<Head, Tail...>>
    : std::conditional_t<
        Predicate<Head>::value,
        split_variant<std::variant<V1s..., Head>, std::variant<V2s...>, Predicate, std::variant<Tail...>>,
        split_variant<std::variant<V1s...>, std::variant<V2s..., Head>, Predicate, std::variant<Tail...>>
    > { };
}

template <class V, template <class> class Predicate>
using split_variant = detail::split_variant<std::variant<>, std::variant<>, Predicate, V>;

Смотрите его в прямом эфире на Wandbox

2 голосов
/ 04 марта 2020

РЕДАКТИРОВАТЬ Учитывая, что пустой вариант (std::variant<>) плохо сформирован (согласно cppreference ), и вместо этого следует использовать std::variant<std::monostate>, я изменил ответ ( добавлена ​​специализация tuple2variant() для пустого кортежа) для поддержки случая, когда список типов для V1 или V2 пуст.

Это небольшой decltype() бред, но ... если вы объявите пару функций вспомогательного фильтра следующим образом 

template <bool B, typename T>
constexpr std::enable_if_t<B == std::is_arithmetic_v<T>, std::tuple<T>>
   filterArithm ();

template <bool B, typename T>
constexpr std::enable_if_t<B != std::is_arithmetic_v<T>, std::tuple<>>
   filterArithm ();

и функцию кортежа к варианту (со специализацией для пустых кортежей, чтобы избежать пустого std::variant) 

std::variant<std::monostate> tuple2variant (std::tuple<> const &);

template <typename ... Ts>
std::variant<Ts...> tuple2variant (std::tuple<Ts...> const &);

ваш класс просто (?) становится 

template <typename ... Ts>
struct TheAnswer<std::variant<Ts...>>
 {
   using V1 = decltype(tuple2variant(std::declval<
                 decltype(std::tuple_cat( filterArithm<true, Ts>()... ))>()));
   using V2 = decltype(tuple2variant(std::declval<
                 decltype(std::tuple_cat( filterArithm<false, Ts>()... ))>()));
 };

Если вы хотите что-то более обобщенное c (если вы хотите передать std::arithmetic в качестве параметра шаблона), вы можете изменить функцию filterArithm(), передав параметр фильтра шаблона-шаблона F (переименован filterType()) 

template <template <typename> class F, bool B, typename T>
constexpr std::enable_if_t<B == F<T>::value, std::tuple<T>>
   filterType ();

template <template <typename> class F, bool B, typename T>
constexpr std::enable_if_t<B != F<T>::value, std::tuple<>>
   filterType ();

Класс TheAnswer становится 

template <typename, template <typename> class>
struct TheAnswer;

template <typename ... Ts, template <typename> class F>
struct TheAnswer<std::variant<Ts...>, F>
 {
   using V1 = decltype(tuple2variant(std::declval<decltype(
                 std::tuple_cat( filterType<F, true, Ts>()... ))>()));
   using V2 = decltype(tuple2variant(std::declval<decltype(
                 std::tuple_cat( filterType<F, false, Ts>()... ))>()));
 };

, а объявление TA принимает также std::is_arithmetic 

using TA = TheAnswer<std::variant<bool, char, std::string, int, float,
                                  double, std::vector<int>>,
                     std::is_arithmetic>;

Ниже приведен полный пример компиляции с std::is_arithmetic в качестве параметра и V2 пустой кейс 

#include <tuple>
#include <string>
#include <vector>
#include <variant>
#include <type_traits>

std::variant<std::monostate> tuple2variant (std::tuple<> const &);

template <typename ... Ts>
std::variant<Ts...> tuple2variant (std::tuple<Ts...> const &);

template <template <typename> class F, bool B, typename T>
constexpr std::enable_if_t<B == F<T>::value, std::tuple<T>>
   filterType ();

template <template <typename> class F, bool B, typename T>
constexpr std::enable_if_t<B != F<T>::value, std::tuple<>>
   filterType ();

template <typename, template <typename> class>
struct TheAnswer;

template <typename ... Ts, template <typename> class F>
struct TheAnswer<std::variant<Ts...>, F>
 {
   using V1 = decltype(tuple2variant(std::declval<decltype(
                 std::tuple_cat( filterType<F, true, Ts>()... ))>()));
   using V2 = decltype(tuple2variant(std::declval<decltype(
                 std::tuple_cat( filterType<F, false, Ts>()... ))>()));
 };

int main ()
 {
   using TA = TheAnswer<std::variant<bool, char, std::string, int, float,
                                     double, std::vector<int>>,
                        std::is_arithmetic>;
   using TB = TheAnswer<std::variant<bool, char, int, float, double>,
                        std::is_arithmetic>;

   using VA1 = std::variant<bool, char, int, float, double>;
   using VA2 = std::variant<std::string, std::vector<int>>;
   using VB1 = VA1;
   using VB2 = std::variant<std::monostate>;

   static_assert( std::is_same_v<VA1, TA::V1> );
   static_assert( std::is_same_v<VA2, TA::V2> );
   static_assert( std::is_same_v<VB1, TB::V1> );
   static_assert( std::is_same_v<VB2, TB::V2> );
 }
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Похожие темы

...