Substitute fully instantiated classes with partially instantiated ancestor classes - c++

Question

I want accepted_dense_vector<??>::value to return 'true' when I give template parameters in the form:
C<T> when C is uvector, dynamic_array and T is std::is_arithmetic.
std::array<T,S> when T is std::is_arithmetic.
container_reference<C> when accepted_dense_vector<C>::value is 'true'.
All works fine, but in derived, fully instantiated classes A, C, D, I want to remove the workaround parent definition.
How can I do this?
#include <iostream>
#include <array>
using namespace std;
// Definition of used types.
template<typename T> struct dynamic_array {};
template<typename T> struct uvector {};
struct A : public uvector<double> { typedef uvector<double> parent; };
struct C : public A { typedef A parent; };
struct D : public std::array<double,5> { typedef std::array<double,5> parent; };
template<typename T> struct B : public uvector<T> { typedef uvector<T> parent; };
template<typename T> struct container_reference {};
// Catches 'false', A, C, D ======== HERE IT IS !!! ========
template<typename C> struct accepted_dense_vector
{
template<typename C1 = C>
static typename std::enable_if<accepted_dense_vector<typename C1::parent>::value, std::true_type>::type helper(const C&);
static std::false_type helper(...);
constexpr static bool value = decltype(helper(std::declval<C>()))::value;
};
// Catches C<T>
template<template<typename> class C, typename T>
struct accepted_dense_vector<C<T>>
{
constexpr static bool value = std::is_arithmetic<T>::value &&
(std::is_base_of<uvector<T>, C<T>>::value || std::is_base_of<dynamic_array<T>, C<T>>::value);
};
// Catches std::array<T,S>
template<typename T, size_t S>
struct accepted_dense_vector<std::array<T,S>>
{ constexpr static bool value = std::is_arithmetic<T>::value; };
// Catches container_reference<C>
template<typename C>
struct accepted_dense_vector<container_reference<C>>
{ constexpr static bool value = accepted_dense_vector<C>::value; };
int main()
{ // Tests!
cout << accepted_dense_vector<std::array<double, 5>>::value << endl;
cout << accepted_dense_vector<uvector<double>>::value << endl;
cout << accepted_dense_vector<A>::value << endl;
cout << accepted_dense_vector<D>::value << endl;
cout << accepted_dense_vector<B<int>>::value << endl;
cout << accepted_dense_vector<container_reference<uvector<double>>>::value << endl;
cout << accepted_dense_vector<int>::value << endl;
return 0;
}

Answer 1

You can go further with your solution. First, you do not need std::enable_if. The code will be more readable. Then, instead of using std::true_type, use a custom struct that will call accepted_dense_vector:
template<typename T>
struct forwarder
{
constexpr static bool value = accepted_dense_vector<T>::value;
};
template<typename T>
static forwarder<uvector<T>> inherit_uvector(uvector<T>*);
static std::false_type inherit_uvector(...);
Then, to know whether the type satisfy accepted... by inheritance of uvector<T>, just use the following line:
constexpr static bool is_uvector = decltype(inherit_uvector(new C()))::value;
// C is the template parameter of accepted_dense_vector
How does this works ?
if C inherits uvector<T>, the first static function is choosed, and decltype will return forwarder<uvector<T>>. Then, 'calling' ::value on it will call accepted....
else, if C does not inherits uvector<T>, the second function is choosed, and decltype will return std::false_type.
The same trick can be used with the other inheritances. Also, B<T> was catched with the second specialization of accepted.... Thus, the ::parent typedef is not needed anymore.
Here is the full code (live here):
#include <iostream>
#include <array>
#include <string>
using namespace std;
// Definition of used types.
template<typename T> struct uvector {};
template<typename T> struct dynamic_array {};
template<typename T> struct container_reference {};
struct A : public uvector<double> {};
template<typename T> struct B : public uvector<T> {};
struct C : public A {};
struct D : public std::array<double,5> {};
struct E : public uvector<string> {};
struct F : public std::array<string,16> {};
// Catches 'false', A, C, D ======== HERE IT IS !!! ========
template<typename C>
struct accepted_dense_vector
{
template<typename T>
struct forwarder
{
constexpr static bool value = accepted_dense_vector<T>::value;
};
// uvector
template<typename T>
static forwarder<uvector<T>> inherit_uvector(uvector<T>*);
static std::false_type inherit_uvector(...);
// std::array
template<typename T, size_t S>
static forwarder<std::array<T,S>> inherit_stdarray(std::array<T,S>*);
static std::false_type inherit_stdarray(...);
// same for dynamic_array<T>
constexpr static bool is_uvector = decltype(inherit_uvector(new C()))::value;
constexpr static bool is_stdarray = decltype(inherit_stdarray(new C()))::value;
constexpr static bool value = is_uvector || is_stdarray;
};
// Catches C<T>
// /!\ Also catches anything which is template<typename> class (for example, B)
// => B::parent is not needed, because of the use of std::is_base_of
template<template<typename> class C, typename T>
struct accepted_dense_vector<C<T>>
{
constexpr static bool value = std::is_arithmetic<T>::value &&
(std::is_base_of<uvector<T>, C<T>>::value || std::is_base_of<dynamic_array<T>, C<T>>::value);
};
// Catches std::array<T,S>
template<typename T, size_t S>
struct accepted_dense_vector<std::array<T,S>>
{
constexpr static bool value = std::is_arithmetic<T>::value;
};
// Catches container_reference<C>
template<typename C>
struct accepted_dense_vector<container_reference<C>>
{
constexpr static bool value = accepted_dense_vector<C>::value;
};
int main()
{ // Tests!
cout << "array = " << accepted_dense_vector<std::array<double, 5>>::value << endl;
cout << "uvector = " << accepted_dense_vector<uvector<double>>::value << endl;
cout << "ref = " << accepted_dense_vector<container_reference<uvector<double>>>::value << endl;
cout << "A = " << accepted_dense_vector<A>::value << endl;
cout << "B = " << accepted_dense_vector<B<int>>::value << endl;
cout << "C = " << accepted_dense_vector<C>::value << endl;
cout << "D = " << accepted_dense_vector<D>::value << endl;
cout << "E = " << accepted_dense_vector<E>::value << endl;
cout << "F = " << accepted_dense_vector<F>::value << endl;
cout << "int = " << accepted_dense_vector<int>::value << endl;
return 0;
}