Выберите функцию для применения в зависимости от действительности выражения

В C++14 проблема заключается в следующем:

Пусть две функции FV&& valid_f, FI&& invalid_f и аргументы Args&&... args
Функция apply_on_validity должна применяться valid_f на args, если выражение std::forward<FV>(valid_f)(std::forward<Args>(args)...) действительно
В противном случае, и если std::forward<FV>(invalid_f)(std::forward<Args>(args)...) является допустимым выражением, apply_on_validity должен применить invalid_f к args
В противном случае apply_on_validity ничего не должен делать

Я предполагаю, что код должен выглядеть примерно так:

template <class FV, class FI, class... Args, /* Some template metaprog here */>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    // Apply valid_f by default
    std::forward<FV>(valid_f)(std::forward<Args>(args)...);
}

template <class FV, class FI, class... Args, /* Some template metaprog here */>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    // Apply invalid_f if valid_f does not work
    std::forward<FV>(invalid_f)(std::forward<Args>(args)...);
}

template <class FV, class FI, class... Args, /* Some template metaprog here */>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    // Do nothing when neither valid_f nor invalid_f work
}

Но я действительно не знаю, как это сделать. Любая идея?

Ссылка на обобщение здесь.

Ответы

Ответ 1

Take:

template <int N> struct rank : rank<N-1> {};
template <> struct rank<0> {};

а затем:

template <class FV, class FI, class... Args>
auto apply_on_validity_impl(rank<2>, FV&& valid_f, FI&& invalid_f, Args&&... args)
    -> decltype(std::forward<FV>(valid_f)(std::forward<Args>(args)...), void())
{
    std::forward<FV>(valid_f)(std::forward<Args>(args)...);
}

template <class FV, class FI, class... Args>
auto apply_on_validity_impl(rank<1>, FV&& valid_f, FI&& invalid_f, Args&&... args)
    -> decltype(std::forward<FI>(invalid_f)(std::forward<Args>(args)...), void())
{
    std::forward<FI>(invalid_f)(std::forward<Args>(args)...);
}

template <class FV, class FI, class... Args>
void apply_on_validity_impl(rank<0>, FV&& valid_f, FI&& invalid_f, Args&&... args)
{

}

template <class FV, class FI, class... Args>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    return apply_on_validity_impl(rank<2>{}, std::forward<FV>(valid_f), std::forward<FI>(invalid_f), std::forward<Args>(args)...);
}

DEMO

Ответ 2

Ответ Пиотра Скотницки превосходный, но такой код заставляет меня почувствовать, насколько ясен С++ 17 благодаря constexpr if и дополнительным типа is_callable: ~~Демо~~ Демо ^{* Эта версия создает больше предупреждений, но проще}

template <class FV, class FI, class... Args>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    if constexpr (std::is_callable_v<FV(Args...)>)
        std::cout << "Apply valid_f by default\n";
    else
    {
        if constexpr (std::is_callable_v<FI(Args...)>)
            std::cout << "Apply invalid_f if valid_f does not work\n";
        else
            std::cout << "Do nothing when neither valid_f nor invalid_f work\n";
    }
}

Ответ 3

Вот альтернативный ответ, просто для ударов. Нам нужен static_if:

template <class T, class F> T&& static_if(std::true_type, T&& t, F&& ) { return std::forward<T>(t); }
template <class T, class F> F&& static_if(std::false_type, T&& , F&& f) { return std::forward<F>(f); }

И is_callable. Поскольку вы просто поддерживаете функции, мы можем сделать это как:

template <class Sig, class = void>
struct is_callable : std::false_type { };

template <class F, class... Args>
struct is_callable<F(Args...), void_t<decltype(std::declval<F>()(std::declval<Args>()...))>>
: std::true_type
{ };

И тогда мы можем построить логику на месте:

template <class FV, class FI, class... Args>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
    auto noop = [](auto&&...) {};

    static_if(
        is_callable<FV&&(Args&&...)>{},
        std::forward<FV>(valid_f),
        static_if(
            std::is_callable<FI&&(Args&&...)>{},
            std::forward<FI>(invalid_f),
            noop
        )
    )(std::forward<Args>(args)...);
}

Ответ 4

Во-первых, домашняя версия С++ 2a is_detected:

#include <utility>
#include <type_traits>
#include <iostream>
#include <tuple>

namespace details {
  template<class...>using void_t=void;
  template<template<class...>class Z, class=void, class...Ts>
  struct can_apply:std::false_type{};
  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, void_t<Z<Ts...>>, Ts...>:std::true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply = typename details::can_apply<Z, void, Ts...>::type;

Как это бывает, std:: result_of_t - это признак, который мы хотим проверить.

template<class Sig>
using can_call = can_apply< std::result_of_t, Sig >;

теперь can_call < Некоторые (Sig, Goes, Here) > являются true_type, если вы можете вызывать выражение.

Теперь мы пишем какое-то время компиляции в рассылке.

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_v{};

constexpr inline index_t<0> dispatch_index() { return {}; }
template<class B0, class...Bs,
  std::enable_if_t<B0::value, int> =0
>
constexpr index_t<0> dispatch_index( B0, Bs... ) { return {}; }
template<class B0, class...Bs,
  std::enable_if_t<!B0::value, int> =0
>
constexpr auto dispatch_index( B0, Bs... ) { 
  return index_v< 1 + dispatch_index( Bs{}...) >;
}

template<class...Bs>
auto dispatch( Bs... ) {
  using I = decltype(dispatch_index( Bs{}... ));
  return [](auto&&...args){
    return std::get<I::value>( std::make_tuple(decltype(args)(args)..., [](auto&&...){}) );
  };
}

отправка (SomeBools...) возвращает лямбда. Первый из SomeBools, который является правдой времени компиляции (имеет значение::, которое вычисляет значение true в булевом контексте) определяет, что делает возвращенная лямбда. Вызовите этот индекс.

Он возвращает аргумент dispatch_index'd для следующего вызова и пустой лямбда, если это один конец прошлого списка.

template <class FV, class FI, class... Args /*, Some template metaprog here */>
void apply_on_validity(FV&& valid_f, FI&& invalid_f, Args&&... args)
{
  dispatch(
    can_call<FV(Args...)>{},
    can_call<FI(Args...)>{}
  )(
    [&](auto&& valid_f, auto&&)->decltype(auto) {
      return decltype(valid_f)(valid_f)(std::forward<Args>(args)...);
    },
    [&](auto&&, auto&& invalid_f)->decltype(auto) {
      return decltype(invalid_f)(valid_f)(std::forward<Args>(args)...);
    }
  )(
    valid_f, invalid_f
  );
}

и сделано, живой пример.

Мы могли бы сделать этот родовой вариант, чтобы включить версию nary. Первый index_over:

template<class=void,  std::size_t...Is >
auto index_over( std::index_sequence<Is...> ){
  return [](auto&&f)->decltype(auto){
    return decltype(f)(f)( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto index_over(std::integral_constant<std::size_t, N> ={}){
  return index_over(std::make_index_sequence<N>{} );
}

Затем auto_dispatch:

template<class...Fs>
auto auto_dispatch( Fs&&... fs ) {
  auto indexer =  index_over<sizeof...(fs)>();
  auto helper = [&](auto I)->decltype(auto){ 
    return std::get<decltype(I)::value>( std::forward_as_tuple( decltype(fs)(fs)... ) );
  };
  return indexer
  (
    [helper](auto...Is){
      auto fs_tuple = std::forward_as_tuple( helper(Is)... );
      return [fs_tuple](auto&&...args) {
        auto dispatcher = dispatch(can_call<Fs(decltype(args)...)>{}...);
        auto&& f0 = dispatcher(std::get<decltype(Is)::value>(fs_tuple)...);
        std::forward<decltype(f0)>(f0)(decltype(args)(args)...);
      };
    }
  );
}

с тестовым кодом:

auto a = [](int x){ std::cout << x << "\n"; };
auto b = [](std::string y){ std::cout << y << "\n";  };
struct Foo {};
auto c = [](Foo){ std::cout << "Foo\n";  };
int main() {
  auto_dispatch(a, c)( 7 );
  auto_dispatch(a, c)( Foo{} );
  auto_dispatch(a, b, c)( Foo{} );
  auto_dispatch(a, b, c)( "hello world" );
}

Пример в реальном времени