Checking for a nested, templated class - c++

Question

I'm trying to build a trait that checks for the existence of a nested, templated class. This is my take for checking whether a class O has a nested class inner with template parameter T:
template <typename O, typename T> struct has_inner {
static const bool value = std::is_class<typename O::template inner<T> >::value;
};
However, this does not work properly. Given two example classes dummy and ok
struct dummy {};
struct ok {
template <typename T>
struct inner {
};
};
The check on ok
std::cout << std::boolalpha << has_inner<ok, float>::value << std::endl;
will work, whereas the check on dummy
std::cout << std::boolalpha << has_inner<dummy, int>::value << std::endl;
will fail to compile on clang 3.2 with the error
error: 'inner' following the 'template' keyword does not refer to a template
static const bool value = std::is_class<typename O::template inner<T> >::value;
^~~~~
note: in instantiation of template class 'has_inner<dummy, int>' requested here
std::cout << std::boolalpha << has_inner<dummy, int>::value << std::endl;
It appears that the compiler tries to actually form that templated expression prior to passing it on to std::is_class. Consequently I see two solutions:
Tell the compiler to delay the template expansion, or
Use a different approach altogether.
However, I don't know how to perform either, can anyone help?

Answer 1

THE PROBLEM
You normally implement traits like this using, and relying on, SFINAE, something which your implementation doesn't take advantage of.
As stated the compiler will try to instantiate typename O::template inner<T>, no matter if it's possible or not; and if it isn't possible the compiler will throw an error diagnostic in your face.
What you need to do is a conditional check to see if T actually has a template-class inside it, without instantiating it if it hasn't.
THE SOLUTION - SFINAE TO THE RESCUE!
An implementation might look like the below snippet, an explanation will follow.
namespace impl {
template<class T, class... Args>
struct has_inner {
template<class U, typename = typename U::template inner<Args...>> // (A)
static std::true_type test (int);
template<class U>
static std::false_type test (...); // (B)
using result_type = decltype (test<T> (0)); // (C)
};
}
template<class... Ts>
using has_inner = typename impl::has_inner<Ts...>::result_type;
Note: by using decltype(test<T>(0)) we will have either std::true_type, or std::false_type which are both the standard behavior when dealing with results from type-traits.
The rules of SFINAE states that if a function template would yield an invalid function declaration upon instantiation, it is as if this function didn't exist, the compiler will try searching for another match, instead of giving up.
This is what happens at (C), we try to call (A) but if that fails (ie. an invalid expression is yield inside template<class U, typename ...> we will end up calling (B).
(B) isn't as good match as a successful instantiation of (A), but if (A) can't be instantiated.. (B) will do.

Answer 2

You need to use a trait class and SFINAE, something like this:
template<class A, typename B>
struct has_inner
{
private:
template<class T, typename U>
static std::true_type has(typename T::template inner<U>*);
template<class, typename>
static std::false_type has(...);
public:
static constexpr auto value = decltype(has<A, B>(nullptr))::value;
};
Now you can use it with correct results:
static_assert(has_inner<ok, float>::value, "ok does not have inner"); // OK
static_assert(has_inner<dummy, float>::value, "dummy does not have inner"); // ERROR