Najpierw homebrew wersja C++ 2a na 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;
Tak się składa, że std :: result_of_t jest cechą, którą chcemy przetestować.
template<class Sig>
using can_call = can_apply< std::result_of_t, Sig >;
teraz can_call < Niektórzy (Sig, Goes, tutaj)> jest true_type IFF ekspresji chcesz można nazwać.
Teraz piszemy trochę czasu na kompilację w przypadku maszyn wysyłkowych.
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&&...){}));
};
}
wysyłka (SomeBools ...) zwraca wartość lambda. Pierwszy z SomeBools, który jest prawdą podczas kompilacji (ma wartość :: która sprawdza się w kontekście boolowskim), określa, co robi zwracana lambda. Zadzwoń do indeksu wysyłki.
Zwraca argument dispatch_index'd do następnego połączenia i pustą wartość lambda, jeśli jest to jeden-koniec-koniec listy.
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
);
}
i gotowe, live example.
Moglibyśmy zrobić ten rodzajowy, aby umożliwić niedrogą wersję. Pierwszy 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>{});
}
Następnie 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)...);
};
}
);
}
z kodem testu:
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");
}
Live example
można rozważyć patrząc na [ 'void_t'] (http: // en.cppreference.com/w/cpp/types/void_t) i mając SFINAE w oparciu o wyrażenie 'void_t'. – vsoftco
ale czy chcesz to, gdy 'valid_f' i' invalid_f' są argumentami 'apply_on_validity()'? Nie z dwoma znanymi i naprawionymi funkcjami? – max66
Nie mogę * czekać * na 'jeśli constexpr' ... – Barry