I've implemented a few traits classes (code attached below) that, for a given callable-type T, and a set of Args..., detects whether the function call T::operator()(Args...) would be
(1) valid,
(2) ambiguous, or
(3) none is viable.
where T is allowed to have arbitrary overloaded operator()'s.
This could be useful for programmers who want to
(1) make the function call only when it's valid,
(2) generate customized error/warning messages when it's ambiguous, or handle/redirect it without getting an ambiguous compiler error, and
(3) redirect non-viable calls to some default behavior, which can be different than how it's handled when the call is ambiguous.
If people are interested, I suppose this could be a useful addition to TypeTraits.
I would appreciate any feedback!
For clarity, the implementation and demonstration attached below is written in c++11. It can be easily ported to c++98/03 compilers by using TypeTratis to replace the std type traits, BOOST_TYPEOF_KEYWORD to replace decltype, and Boost.Preprocessor to generate code for arbitrary arity.
- Hui Li
#include <utility>
#include <type_traits>
template < typename T > struct is_callable;
template < typename Signature > struct has_valid_call;
template < typename Signature > struct has_ambiguous_call;
template < typename Signature > struct has_no_viable_call;
template < typename T >
struct is_callable
{
struct yes {};
struct no {};
struct ambiguate_seed { void operator()(); };
template < typename U, bool=std::is_class<U>::value >
struct ambiguate : U, ambiguate_seed {};
template < typename U >
struct ambiguate<U,false> : ambiguate_seed {};
template < typename U, typename = decltype(&U::operator()) > static constexpr no test(int);
template < typename > static constexpr yes test(...);
static bool constexpr value = std::is_same<decltype(test< ambiguate<T> >(0)),yes>::value ;
typedef std::integral_constant<bool,value> type;
};
template < typename T, typename... Args >
struct has_valid_call< T(Args...) >
{
struct yes {};
struct no {};
template < typename U, bool = is_callable<U>::value >
struct impl
{
template < typename V, typename = typename std::result_of<V(Args...)>::type >
struct test_result { using type = yes; };
template < typename V > static constexpr typename test_result<V>::type test(int);
template < typename > static constexpr no test(...);
static constexpr bool value = std::is_same<decltype(test<U>(0)),yes>::value;
using type = std::integral_constant<bool, value>;
};
template < typename U >
struct impl<U,false> : std::false_type {};
static constexpr bool value = impl<T>::value;
using type = std::integral_constant<bool, value>;
};
template < typename T, typename... Args >
struct has_ambiguous_call< T(Args...) >
{
struct ambiguate_seed { void operator()(...); };
template < class U, bool = is_callable<U>::value >
struct ambiguate : U, ambiguate_seed
{
using ambiguate_seed::operator();
using U::operator();
};
template < class U >
struct ambiguate<U,false> : ambiguate_seed {};
static constexpr bool value = not has_valid_call< ambiguate<T>(Args...) >::value;
using type = std::integral_constant<bool, value>;
};
template < typename T, typename... Args >
struct has_no_viable_call< T(Args...) >
: std::integral_constant<bool,
not (has_valid_call<T(Args...)>::value or has_ambiguous_call<T(Args...)>::value)>
{};
#include <string>
#include <vector>
struct test
{
void operator()(int);
void operator()(double);
void operator()(int,double);
template < typename T >
typename std::enable_if< not std::is_integral<T>::value >::type
operator()(const T&, int=0){}
template < typename T >
typename std::enable_if< std::is_integral<T>::value >::type
operator()(const std::vector<T>&, T*){}
template < typename T >
int operator()(const std::string&, int){}
};
int main(int argc, const char * argv[])
{
static_assert( is_callable<test>::value , "");
static_assert( not is_callable<int>::value , "");
static_assert( has_valid_call<test(char const*,long)>::value , "");
static_assert( has_valid_call<test(std::string&,long)>::value , "");
static_assert( has_valid_call<test(std::vector<int>, int*)>::value , "");
static_assert( has_no_viable_call<test(std::vector<double>, double*)>::value , "");
static_assert( has_valid_call<test(int)>::value , "");
static_assert( has_valid_call<test(int,double)>::value , "");
static_assert( not has_valid_call<test(int,double,int)>::value , "");
static_assert( not has_ambiguous_call<test(double)>::value , "");
static_assert( has_ambiguous_call<test(unsigned)>::value , "");
static_assert( not has_no_viable_call<test(unsigned)>::value , "");
static_assert( not has_no_viable_call<test(int)>::value , "");
static_assert( has_no_viable_call<test(void)>::value , "");
return 0;
}
